feat: release 2.0.6

feat(dream): add memory dream cli and docs
2026-06-03 02:27:09 +08:00 · 2026-04-14 12:37:53 +08:00 · 2026-04-14 12:08:57 +08:00 · 2026-04-14 11:03:53 +08:00 · 2026-04-13 22:08:15 +08:00 · 2026-04-13 21:32:52 +08:00
189 changed files with 13926 additions and 3547 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -36,6 +36,7 @@ plugins/banwords/lib/__pycache__
 !plugins/cow_cli
 client_config.json
 ref/
+**/.dev.vars
 .cursor/
 local/
 node_modules/
--- a/README.md
+++ b/README.md
@@ -1,18 +1,19 @@
-<p align="center"><img src= "https://github.com/user-attachments/assets/eca9a9ec-8534-4615-9e0f-96c5ac1d10a3" alt="Chatgpt-on-Wechat" width="550" /></p>
+<p align="center"><img src= "https://github.com/user-attachments/assets/eca9a9ec-8534-4615-9e0f-96c5ac1d10a3" alt="CowAgent" width="550" /></p>

 <p align="center">
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/chatgpt-on-wechat" alt="Latest release"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/chatgpt-on-wechat" alt="License: MIT"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat"><img src="https://img.shields.io/github/stars/zhayujie/chatgpt-on-wechat?style=flat-square" alt="Stars"></a> <br/>
+  <a href="https://github.com/zhayujie/CowAgent/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/CowAgent" alt="Latest release"></a>
+  <a href="https://github.com/zhayujie/CowAgent/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/CowAgent" alt="License: MIT"></a>
+  <a href="https://github.com/zhayujie/CowAgent"><img src="https://img.shields.io/github/stars/zhayujie/CowAgent?style=flat-square" alt="Stars"></a> <br/>
  [中文] | [<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;
  <a href="https://docs.cowagent.ai/">📖 文档中心</a> &nbsp;·&nbsp;
  <a href="https://docs.cowagent.ai/guide/quick-start">🚀 快速开始</a> &nbsp;·&nbsp;
+  <a href="https://skills.cowagent.ai/">🧩 技能广场</a> &nbsp;·&nbsp;
  <a href="https://link-ai.tech/cowagent/create">☁️ 在线体验</a>
 </p>

@@ -21,12 +22,15 @@

 > 该项目既是一个可以开箱即用的超级 AI 助理，也是一个支持高扩展的 Agent 框架，可以通过为项目扩展大模型接口、接入渠道、内置工具、Skills 系统来灵活实现各种定制需求。核心能力如下：

-  ✅  **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持通过工具操作访问文件、终端、浏览器、定时任务等系统资源
-  ✅  **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索
-  ✅  **技能系统：** 实现了 Skills 创建和运行的引擎，内置多种技能，并支持通过自然语言对话完成自定义 Skills 开发
+-  ✅  **自主任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标
+-  ✅  **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括核心记忆、日级记忆和梦境蒸馏，支持关键词及向量检索
+-  ✅  **个人知识库：** 自动整理结构化知识，通过交叉引用构建知识图谱，支持通过对话管理和可视化浏览知识库
+-  ✅  **技能系统：** Skills 安装和运行的引擎，支持从 [Skill Hub](https://skills.cowagent.ai/)、GitHub 等一键安装技能，或通过对话创造 Skills
+-  ✅  **工具系统：** 内置文件读写、终端执行、浏览器操作、定时任务等工具，Agent 自主调用以完成复杂任务
+-  ✅  **CLI系统：** 提供终端命令和对话命令，支持进程管理、技能安装、配置修改等操作
 -  ✅  **多模态消息：** 支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作
-  ✅  **多模型接入：** 支持 OpenAI, Claude, Gemini, DeepSeek, MiniMax、GLM、Qwen、Kimi、Doubao 等国内外主流模型厂商
-  ✅  **多端部署：** 支持运行在本地计算机或服务器，可集成到微信、飞书、钉钉、企业微信、QQ、微信公众号、网页中使用
+-  ✅  **多模型支持：** 支持 OpenAI, Claude, Gemini, DeepSeek, MiniMax、GLM、Qwen、Kimi、Doubao 等国内外主流模型厂商
+-  ✅  **多通道接入：** 支持运行在本地计算机或服务器，可集成到微信、飞书、钉钉、企业微信、QQ、微信公众号、网页中使用

 ## 声明

@@ -66,15 +70,19 @@

 # 🏷 更新日志

->**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.04.14：** [2.0.6版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.6)，知识库系统、梦境记忆模块、上下文智能压缩、Web 控制台多会话及多项优化。

->**2026.03.18：** [2.0.3版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.3)，新增企微智能机器人和 QQ 通道、支持 Coding Plan、新增多个模型、Web 端文件处理、记忆系统升级。
+>**2026.04.01：** [2.0.5版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.5)，Cow CLI 命令系统、Skill Hub 开源、浏览器工具、企微扫码创建、多项优化和修复。

->**2026.02.27：** [2.0.2版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.2)，Web 控制台全面升级（流式对话、模型/技能/记忆/通道/定时任务/日志管理）、支持多通道同时运行、会话持久化存储、新增多个模型。
+>**2026.03.22：** [2.0.4版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.4)，新增个人微信通道（微信扫码即用）、新增 MiniMax-M2.7 和 GLM-5-Turbo 模型、run.sh 脚本重构、日文文档及多项修复。

->**2026.02.13：** [2.0.1版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.1)，内置 Web Search 工具、智能上下文裁剪策略、运行时信息动态更新、Windows 兼容性适配，修复定时任务记忆丢失、飞书连接等多项问题。
+>**2026.03.18：** [2.0.3版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.3)，新增企微智能机器人和 QQ 通道、支持 Coding Plan、新增多个模型、Web 端文件处理、记忆系统升级。

->**2026.02.03：** [2.0.0版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)，正式升级为超级 Agent 助理，支持多轮任务决策、具备长期记忆、实现多种系统工具、支持 Skills 框架，新增多种模型并优化了接入渠道。
+>**2026.02.27：** [2.0.2版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.2)，Web 控制台全面升级（流式对话、模型/技能/记忆/通道/定时任务/日志管理）、支持多通道同时运行、会话持久化存储、新增多个模型。
+
+>**2026.02.13：** [2.0.1版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.1)，内置 Web Search 工具、智能上下文裁剪策略、运行时信息动态更新、Windows 兼容性适配，修复定时任务记忆丢失、飞书连接等多项问题。
+
+>**2026.02.03：** [2.0.0版本](https://github.com/zhayujie/CowAgent/releases/tag/2.0.0)，正式升级为超级 Agent 助理，支持多轮任务决策、具备长期记忆、实现多种系统工具、支持 Skills 框架，新增多种模型并优化了接入渠道。

 更多更新历史请查看: [更新日志](https://docs.cowagent.ai/releases)

@@ -86,11 +94,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/cli/index) 管理服务。


 ## 一、准备
@@ -105,18 +119,18 @@ bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)

 ### 2.环境安装

-支持 Linux、MacOS、Windows 操作系统，可在个人计算机及服务器上运行，需安装 `Python`，Python 版本需在3.7 ~ 3.12 之间，推荐使用3.9版本。
+支持 Linux、MacOS、Windows 操作系统，可在个人计算机及服务器上运行，需安装 `Python`，Python 版本需在 3.7 ~ 3.13 之间。

 > 注意：Agent 模式推荐使用源码运行，若选择 Docker 部署则无需安装 python 环境和下载源码，可直接快进到下一节。

 **(1) 克隆项目代码：**

 ```bash
-git clone https://github.com/zhayujie/chatgpt-on-wechat
-cd chatgpt-on-wechat/
+git clone https://github.com/zhayujie/CowAgent
+cd CowAgent/
 ```

-若遇到网络问题可使用国内仓库地址：https://gitee.com/zhayujie/chatgpt-on-wechat
+若遇到网络问题可使用国内仓库地址：https://gitee.com/zhayujie/CowAgent

 **(2) 安装核心依赖 (必选)：**

@@ -134,6 +148,24 @@ pip3 install -r requirements-optional.txt

 如果某项依赖安装失败可注释掉对应的行后重试。

+**(4) 安装 Cow CLI (推荐)：**
+
+```bash
+pip3 install -e .
+```
+
+安装后可使用 `cow` 命令管理服务（启动、停止、更新等）和技能，详见 [命令文档](https://docs.cowagent.ai/cli/index)。
+
+**(5) 安装浏览器工具 (可选)：**
+
+如果需要 Agent 操作浏览器（如访问网页、填写表单等），需要额外安装浏览器依赖：
+
+```bash
+cow install-browser
+```
+
+该命令会自动安装 `playwright` 和 Chromium 浏览器，国内网络自动使用镜像加速。详见 [浏览器工具文档](https://docs.cowagent.ai/tools/browser)。
+
 ## 二、配置

 配置文件的模板在根目录的 `config-template.json` 中，需复制该模板创建最终生效的 `config.json` 文件：
@@ -168,11 +200,13 @@ pip3 install -r requirements-optional.txt
  "group_speech_recognition": false,                          # 是否开启群组语音识别
  "voice_reply_voice": false,                                 # 是否使用语音回复语音
  "use_linkai": false,                                        # 是否使用 LinkAI 接口，默认关闭，设置为 true 后可对接 LinkAI 平台模型
+  "web_password": "",                                         # Web 控制台访问密码，留空则不启用密码保护
  "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 模式下单次任务的最大决策步数，超出后将停止继续调用工具
+  "agent_max_context_tokens": 50000,                          # Agent 模式下最大上下文 tokens，超出将自动智能压缩处理
+  "agent_max_context_turns": 20,                              # Agent 模式下最大上下文记忆轮次，一问一答为一轮，超出后智能压缩处理
+  "agent_max_steps": 20,                                      # Agent 模式下单次任务的最大决策步数，超出后将停止继续调用工具
+  "enable_thinking": true                                     # 是否启用深度思考，开启后 Web 端展示模型推理过程，关闭后可加速响应
 }
 ```

@@ -184,12 +218,13 @@ pip3 install -r requirements-optional.txt
 + 添加 `"speech_recognition": true` 将开启语音识别，默认使用 openai 的 whisper 模型识别为文字，同时以文字回复，该参数仅支持私聊 (注意由于语音消息无法匹配前缀，一旦开启将对所有语音自动回复，支持语音触发画图)；
 + 添加 `"group_speech_recognition": true` 将开启群组语音识别，默认使用 openai 的 whisper 模型识别为文字，同时以文字回复，参数仅支持群聊 (会匹配 group_chat_prefix 和 group_chat_keyword, 支持语音触发画图)；
 + 添加 `"voice_reply_voice": true` 将开启语音回复语音（同时作用于私聊和群聊）
+ 使用 MiniMax TTS：设置 `"text_to_voice": "minimax"`，并配置 `minimax_api_key`；可通过 `"tts_voice_id"` 指定发音人（如 `English_Graceful_Lady`），`"text_to_voice_model"` 指定模型（如 `speech-2.8-hd`、`speech-2.8-turbo`）
 </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)文件
+ `model`: 模型名称，Agent 模式下推荐使用 `MiniMax-M2.7`、`glm-5-turbo`、`kimi-k2.5`、`qwen3.6-plus`、`claude-sonnet-4-6`、`gemini-3.1-pro-preview`，全部模型名称参考[common/const.py](https://github.com/zhayujie/CowAgent/blob/master/common/const.py)文件
 + `character_desc`：普通对话模式下的机器人系统提示词。在 Agent 模式下该配置不生效，由工作空间中的文件内容构成。
 + `subscribe_msg`：订阅消息，公众号和企业微信 channel 中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成 bot 的触发词。
 </details>
@@ -201,7 +236,7 @@ pip3 install -r requirements-optional.txt
 + `linkai_api_key`: LinkAI Api Key，可在 [控制台](https://link-ai.tech/console/interface) 创建
 </details>

-注：全部配置项说明可在 [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) 文件中查看。
+注：全部配置项说明可在 [`config.py`](https://github.com/zhayujie/CowAgent/blob/master/config.py) 文件中查看。

 ## 三、运行

@@ -210,7 +245,8 @@ 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` 在网页端对话。
@@ -220,15 +256,24 @@ python3 app.py         # windows 环境下该命令通常为 python app.py

 ### 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 logs` 等命令，执行 `./run.sh help` 可查看全部用法。
+此外，项目根目录下的 `run.sh` 脚本也支持一键管理服务，包括 `./run.sh start`、`./run.sh stop`、`./run.sh restart` 等命令，执行 `./run.sh help` 可查看全部用法。

 > 如果需要通过浏览器访问 Web 控制台，请确保服务器的 `9899` 端口已在防火墙或安全组中放行，建议仅对指定 IP 开放以保证安全。

@@ -264,7 +309,7 @@ sudo docker logs -f chatgpt-on-wechat

 ## 模型说明

-以下对所有可支持的模型的配置和使用方法进行说明，模型接口实现在项目的 `models/` 目录下。
+推荐通过 Web 控制台在线管理模型配置，无需手动编辑文件，详见 [模型文档](https://docs.cowagent.ai/models)。以下是手动修改 `config.json` 配置模型的说明：

 <details>
 <summary>OpenAI</summary>
@@ -318,7 +363,7 @@ sudo docker logs -f chatgpt-on-wechat
    "minimax_api_key": ""
 }
 ```
- - `model`: 可填写 `MiniMax-M2.7、MiniMax-M2.5、MiniMax-M2.1、MiniMax-M2.1-lightning、MiniMax-M2、abab6.5-chat` 等
+ - `model`: 可填写 `MiniMax-M2.7、MiniMax-M2.7-highspeed、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) 创建

 方式二：OpenAI 兼容方式接入，配置如下：
@@ -331,7 +376,7 @@ sudo docker logs -f chatgpt-on-wechat
 }
 ```
 - `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)
+- `model`: 可填 `MiniMax-M2.7、MiniMax-M2.7-highspeed、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
 </details>
@@ -372,18 +417,18 @@ sudo docker logs -f chatgpt-on-wechat

 ```json
 {
-    "model": "qwen3.5-plus",
+    "model": "qwen3.6-plus",
    "dashscope_api_key": "sk-qVxxxxG"
 }
 ```
- - `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) 创建
+ - `model`: 可填写 `qwen3.6-plus、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 兼容方式接入，配置如下：
 ```json
 {
  "bot_type": "openai",
-  "model": "qwen3.5-plus",
+  "model": "qwen3.6-plus",
  "open_ai_api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1",
  "open_ai_api_key": "sk-qVxxxxG"
 }
@@ -635,7 +680,7 @@ Coding Plan 是各厂商推出的编程包月套餐，所有厂商均可通过 O

 ## 通道说明

-以下对可接入通道的配置方式进行说明，应用通道代码在项目的 `channel/` 目录下。
+推荐通过 Web 控制台在线管理通道配置，无需手动编辑文件，详见 [通道文档](https://docs.cowagent.ai/channels/weixin)。以下为手动修改 `config.json` 配置通道的说明：

 支持同时可接入多个通道，配置时可通过逗号进行分割，例如 `"channel_type": "feishu,dingtalk"`。

@@ -669,6 +714,7 @@ Coding Plan 是各厂商推出的编程包月套餐，所有厂商均可通过 O
 ```

 - `web_port`: 默认为 9899，可按需更改，需要服务器防火墙和安全组放行该端口
+- `web_password`: 访问密码，留空则不启用密码保护。部署在公网环境时建议设置
 - 如本地运行，启动后请访问 `http://localhost:9899/chat` ；如服务器运行，请访问 `http://ip:9899/chat` 
 > 注：请将上述 url 中的 ip 或者 port 替换为实际的值
 </details>
@@ -830,25 +876,37 @@ QQ 机器人使用 WebSocket 长连接模式，无需公网 IP 和域名，支

 # 🔗 相关项目

+- [Cow Skill Hub](https://github.com/zhayujie/cow-skill-hub)：开源的 AI Agent 技能广场，浏览、搜索、安装和发布技能，支持 CowAgent、OpenClaw、Claude Code 等多种 Agent。
 - [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)，可访问终端、浏览器、文件系统、搜索引擎 等各类工具，并实现了多智能体协同。
+- [AgentMesh](https://github.com/MinimalFuture/AgentMesh)：开源的多智能体( Multi-Agent )框架，可以通过多智能体团队的协同来解决复杂问题。
+



 # 🔎 常见问题

-FAQs： <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
+FAQs： <https://github.com/zhayujie/CowAgent/wiki/FAQs>

 或直接在线咨询 [项目小助手](https://link-ai.tech/app/Kv2fXJcH)  (知识库持续完善中，回复供参考)

 # 🛠️ 开发

-欢迎接入更多应用通道，参考 [飞书通道](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/CowAgent/blob/master/channel/feishu/feishu_channel.py) 新增自定义通道，实现接收和发送消息逻辑即可完成接入。同时欢迎贡献新的 Skills，向 [Skill Hub](https://skills.cowagent.ai/submit) 提交技能。

 # ✉ 联系

-欢迎提交PR、Issues进行反馈，以及通过 🌟Star 支持并关注项目更新。项目运行遇到问题可以查看 [常见问题列表](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) ，以及前往 [Issues](https://github.com/zhayujie/chatgpt-on-wechat/issues) 中搜索。个人开发者可加入开源交流群参与更多讨论，企业用户可联系[产品客服](https://cdn.link-ai.tech/portal/linkai-customer-service.png)咨询。
+欢迎提交PR、Issues进行反馈，以及通过 🌟Star 支持并关注项目更新。项目运行遇到问题可以查看 [常见问题列表](https://github.com/zhayujie/CowAgent/wiki/FAQs) ，以及前往 [Issues](https://github.com/zhayujie/CowAgent/issues) 中搜索。个人开发者可加入开源交流群参与更多讨论，企业用户可联系[产品客服](https://cdn.link-ai.tech/portal/linkai-customer-service.png)咨询。

 # 🌟 贡献者

-![cow contributors](https://contrib.rocks/image?repo=zhayujie/chatgpt-on-wechat&max=1000)
+![cow contributors](https://contrib.rocks/image?repo=zhayujie/CowAgent&max=1000)
+
+# 📌 项目更名说明
+
+本项目原名 `chatgpt-on-wechat`（GitHub 原地址：https://github.com/zhayujie/chatgpt-on-wechat ），
+于 2026.04.13 正式更名为 **CowAgent**。GitHub 已自动设置重定向，原有链接仍可正常访问。
+
+如需更新本地仓库的远程地址（可选）：
+```bash
+git remote set-url origin https://github.com/zhayujie/CowAgent.git
+```
--- a/agent/chat/service.py
+++ b/agent/chat/service.py
@@ -57,7 +57,16 @@ class ChatService:
            event_type = event.get("type")
            data = event.get("data", {})

-            if event_type == "message_update":
+            if event_type == "reasoning_update":
+                delta = data.get("delta", "")
+                if delta:
+                    send_chunk_fn({
+                        "chunk_type": "reasoning",
+                        "delta": delta,
+                        "segment_id": state.segment_id,
+                    })
+
+            elif event_type == "message_update":
                # Incremental text delta
                delta = data.get("delta", "")
                if delta:
@@ -75,6 +84,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", "")
--- a/agent/knowledge/init.py
+++ b/agent/knowledge/init.py
--- a/agent/knowledge/service.py
+++ b/agent/knowledge/service.py
@@ -0,0 +1,218 @@
+"""
+Knowledge service for handling knowledge base operations.
+
+Provides a unified interface for listing, reading, and graphing knowledge files,
+callable from the web console, API, or CLI.
+
+Knowledge file layout (under workspace_root):
+    knowledge/index.md
+    knowledge/log.md
+    knowledge/<category>/<slug>.md
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+from common.log import logger
+from config import conf
+
+
+class KnowledgeService:
+    """
+    High-level service for knowledge base queries.
+    Operates directly on the filesystem.
+    """
+
+    def __init__(self, workspace_root: str):
+        self.workspace_root = workspace_root
+        self.knowledge_dir = os.path.join(workspace_root, "knowledge")
+
+    # ------------------------------------------------------------------
+    # list — directory tree with stats
+    # ------------------------------------------------------------------
+    def list_tree(self) -> dict:
+        """
+        Return the knowledge directory tree grouped by category.
+
+        Returns::
+
+            {
+                "tree": [
+                    {
+                        "dir": "concepts",
+                        "files": [
+                            {"name": "moe.md", "title": "MoE", "size": 1234},
+                            ...
+                        ]
+                    },
+                    ...
+                ],
+                "stats": {"pages": 15, "size": 32768},
+                "enabled": true
+            }
+        """
+        if not os.path.isdir(self.knowledge_dir):
+            return {"tree": [], "stats": {"pages": 0, "size": 0}, "enabled": conf().get("knowledge", True)}
+
+        tree = []
+        total_files = 0
+        total_bytes = 0
+        for name in sorted(os.listdir(self.knowledge_dir)):
+            full = os.path.join(self.knowledge_dir, name)
+            if not os.path.isdir(full) or name.startswith("."):
+                continue
+            files = []
+            for fname in sorted(os.listdir(full)):
+                if fname.endswith(".md") and not fname.startswith("."):
+                    fpath = os.path.join(full, fname)
+                    size = os.path.getsize(fpath)
+                    total_files += 1
+                    total_bytes += size
+                    title = fname.replace(".md", "")
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            first_line = f.readline().strip()
+                        if first_line.startswith("# "):
+                            title = first_line[2:].strip()
+                    except Exception:
+                        pass
+                    files.append({"name": fname, "title": title, "size": size})
+            tree.append({"dir": name, "files": files})
+
+        return {
+            "tree": tree,
+            "stats": {"pages": total_files, "size": total_bytes},
+            "enabled": conf().get("knowledge", True),
+        }
+
+    # ------------------------------------------------------------------
+    # read — single file content
+    # ------------------------------------------------------------------
+    def read_file(self, rel_path: str) -> dict:
+        """
+        Read a single knowledge markdown file.
+
+        :param rel_path: Relative path within knowledge/, e.g. ``concepts/moe.md``
+        :return: dict with ``content`` and ``path``
+        :raises ValueError: if path is invalid or escapes knowledge dir
+        :raises FileNotFoundError: if file does not exist
+        """
+        if not rel_path or ".." in rel_path:
+            raise ValueError("invalid path")
+
+        full_path = os.path.normpath(os.path.join(self.knowledge_dir, rel_path))
+        allowed = os.path.normpath(self.knowledge_dir)
+        if not full_path.startswith(allowed + os.sep) and full_path != allowed:
+            raise ValueError("path outside knowledge dir")
+
+        if not os.path.isfile(full_path):
+            raise FileNotFoundError(f"file not found: {rel_path}")
+
+        with open(full_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return {"content": content, "path": rel_path}
+
+    # ------------------------------------------------------------------
+    # graph — nodes and links for visualization
+    # ------------------------------------------------------------------
+    def build_graph(self) -> dict:
+        """
+        Parse all knowledge pages and extract cross-reference links.
+
+        Returns::
+
+            {
+                "nodes": [
+                    {"id": "concepts/moe.md", "label": "MoE", "category": "concepts"},
+                    ...
+                ],
+                "links": [
+                    {"source": "concepts/moe.md", "target": "entities/deepseek.md"},
+                    ...
+                ]
+            }
+        """
+        knowledge_path = Path(self.knowledge_dir)
+        if not knowledge_path.is_dir():
+            return {"nodes": [], "links": []}
+
+        nodes = {}
+        links = []
+        link_re = re.compile(r'\[([^\]]*)\]\(([^)]+\.md)\)')
+
+        for md_file in knowledge_path.rglob("*.md"):
+            rel = str(md_file.relative_to(knowledge_path))
+            if rel in ("index.md", "log.md"):
+                continue
+            parts = rel.split("/")
+            category = parts[0] if len(parts) > 1 else "root"
+            title = md_file.stem.replace("-", " ").title()
+            try:
+                content = md_file.read_text(encoding="utf-8")
+                first_line = content.strip().split("\n")[0]
+                if first_line.startswith("# "):
+                    title = first_line[2:].strip()
+                for _, link_target in link_re.findall(content):
+                    resolved = (md_file.parent / link_target).resolve()
+                    try:
+                        target_rel = str(resolved.relative_to(knowledge_path))
+                    except ValueError:
+                        continue
+                    if target_rel != rel:
+                        links.append({"source": rel, "target": target_rel})
+            except Exception:
+                pass
+            nodes[rel] = {"id": rel, "label": title, "category": category}
+
+        valid_ids = set(nodes.keys())
+        links = [l for l in links if l["source"] in valid_ids and l["target"] in valid_ids]
+        seen = set()
+        deduped = []
+        for l in links:
+            key = tuple(sorted([l["source"], l["target"]]))
+            if key not in seen:
+                seen.add(key)
+                deduped.append(l)
+
+        return {"nodes": list(nodes.values()), "links": deduped}
+
+    # ------------------------------------------------------------------
+    # dispatch — single entry point for protocol messages
+    # ------------------------------------------------------------------
+    def dispatch(self, action: str, payload: Optional[dict] = None) -> dict:
+        """
+        Dispatch a knowledge management action.
+
+        :param action: ``list``, ``read``, or ``graph``
+        :param payload: action-specific payload
+        :return: protocol-compatible response dict
+        """
+        payload = payload or {}
+        try:
+            if action == "list":
+                result = self.list_tree()
+                return {"action": action, "code": 200, "message": "success", "payload": result}
+
+            elif action == "read":
+                path = payload.get("path")
+                if not path:
+                    return {"action": action, "code": 400, "message": "path is required", "payload": None}
+                result = self.read_file(path)
+                return {"action": action, "code": 200, "message": "success", "payload": result}
+
+            elif action == "graph":
+                result = self.build_graph()
+                return {"action": action, "code": 200, "message": "success", "payload": result}
+
+            else:
+                return {"action": action, "code": 400, "message": f"unknown action: {action}", "payload": None}
+
+        except ValueError as e:
+            return {"action": action, "code": 403, "message": str(e), "payload": None}
+        except FileNotFoundError as e:
+            return {"action": action, "code": 404, "message": str(e), "payload": None}
+        except Exception as e:
+            logger.error(f"[KnowledgeService] dispatch error: action={action}, error={e}")
+            return {"action": action, "code": 500, "message": str(e), "payload": None}
--- a/agent/memory/conversation_store.py
+++ b/agent/memory/conversation_store.py
@@ -28,11 +28,13 @@ from common.log import logger

 _DDL = """
 CREATE TABLE IF NOT EXISTS sessions (
-    session_id   TEXT    PRIMARY KEY,
-    channel_type TEXT    NOT NULL DEFAULT '',
-    created_at   INTEGER NOT NULL,
-    last_active  INTEGER NOT NULL,
-    msg_count    INTEGER NOT NULL DEFAULT 0
+    session_id        TEXT    PRIMARY KEY,
+    channel_type      TEXT    NOT NULL DEFAULT '',
+    title             TEXT    NOT NULL DEFAULT '',
+    context_start_seq INTEGER NOT NULL DEFAULT 0,
+    created_at        INTEGER NOT NULL,
+    last_active       INTEGER NOT NULL,
+    msg_count         INTEGER NOT NULL DEFAULT 0
 );

 CREATE TABLE IF NOT EXISTS messages (
@@ -57,6 +59,14 @@ _MIGRATION_ADD_CHANNEL_TYPE = """
 ALTER TABLE sessions ADD COLUMN channel_type TEXT NOT NULL DEFAULT '';
 """

+_MIGRATION_ADD_TITLE = """
+ALTER TABLE sessions ADD COLUMN title TEXT NOT NULL DEFAULT '';
+"""
+
+_MIGRATION_ADD_CONTEXT_START_SEQ = """
+ALTER TABLE sessions ADD COLUMN context_start_seq INTEGER NOT NULL DEFAULT 0;
+"""
+
 DEFAULT_MAX_AGE_DAYS: int = 30


@@ -188,8 +198,9 @@ def _group_into_display_turns(
            if text:
                turns.append({"role": "user", "content": text, "created_at": created_at})

-        # Collect all tool_calls and tool_results from the rest of the group
-        all_tool_calls: List[Dict[str, Any]] = []
+        # Build an ordered list of steps preserving the original sequence:
+        #   thinking → content → tool_call → content → ...
+        steps: List[Dict[str, Any]] = []
        tool_results: Dict[str, str] = {}
        final_text = ""
        final_ts: Optional[int] = None
@@ -198,24 +209,46 @@ def _group_into_display_turns(
            if role == "user":
                tool_results.update(_extract_tool_results(content))
            elif role == "assistant":
-                tcs = _extract_tool_calls(content)
-                all_tool_calls.extend(tcs)
-                t = _extract_display_text(content)
-                if t:
-                    final_text = t
+                # Walk content blocks in order to preserve interleaving
+                if isinstance(content, list):
+                    for block in content:
+                        if not isinstance(block, dict):
+                            continue
+                        btype = block.get("type")
+                        if btype == "thinking":
+                            txt = block.get("thinking", "").strip()
+                            if txt:
+                                steps.append({"type": "thinking", "content": txt})
+                        elif btype == "text":
+                            txt = block.get("text", "").strip()
+                            if txt:
+                                steps.append({"type": "content", "content": txt})
+                                final_text = txt
+                        elif btype == "tool_use":
+                            steps.append({
+                                "type": "tool",
+                                "id": block.get("id", ""),
+                                "name": block.get("name", ""),
+                                "arguments": block.get("input", {}),
+                            })
+                elif isinstance(content, str) and content.strip():
+                    steps.append({"type": "content", "content": content.strip()})
+                    final_text = content.strip()
                final_ts = created_at

-        # Attach tool results to their matching tool_call entries
-        for tc in all_tool_calls:
-            tc["result"] = tool_results.get(tc.get("id", ""), "")
+        # Attach tool results to tool steps
+        for step in steps:
+            if step["type"] == "tool":
+                step["result"] = tool_results.get(step.get("id", ""), "")

-        if final_text or all_tool_calls:
-            turns.append({
+        if steps or final_text:
+            turn = {
                "role": "assistant",
                "content": final_text,
-                "tool_calls": all_tool_calls,
+                "steps": steps,
                "created_at": final_ts or (user_row[1] if user_row else 0),
-            })
+            }
+            turns.append(turn)

    return turns

@@ -264,14 +297,21 @@ class ConversationStore:
        with self._lock:
            conn = self._connect()
            try:
+                # Respect context_start_seq: only load messages at or after the boundary
+                ctx_row = conn.execute(
+                    "SELECT context_start_seq FROM sessions WHERE session_id = ?",
+                    (session_id,),
+                ).fetchone()
+                ctx_start = ctx_row[0] if ctx_row else 0
+
                rows = conn.execute(
                    """
                    SELECT seq, role, content
                    FROM messages
-                    WHERE session_id = ?
+                    WHERE session_id = ? AND seq >= ?
                    ORDER BY seq DESC
                    """,
-                    (session_id,),
+                    (session_id, ctx_start),
                ).fetchall()
            finally:
                conn.close()
@@ -279,10 +319,7 @@ class ConversationStore:
        if not rows:
            return []

-        # Walk newest-to-oldest counting *visible* user turns (actual user text,
-        # not tool_result injections).  Record the seq of every visible user
-        # message so we can find a clean cut point later.
-        visible_turn_seqs: List[int] = []  # newest first
+        visible_turn_seqs: List[int] = []
        for seq, role, raw_content in rows:
            if role != "user":
                continue
@@ -293,17 +330,11 @@ class ConversationStore:
            if _is_visible_user_message(content):
                visible_turn_seqs.append(seq)

-        # Determine the seq of the oldest visible user message we want to keep.
-        # If the total turns fit within max_turns, keep everything.
        if len(visible_turn_seqs) <= max_turns:
-            cutoff_seq = None  # keep all
+            cutoff_seq = None
        else:
-            # The Nth visible user message (0-indexed) is the oldest we keep.
            cutoff_seq = visible_turn_seqs[max_turns - 1]

-        # Build result in chronological order, starting from cutoff.
-        # IMPORTANT: we start exactly at cutoff_seq (the visible user message),
-        # never mid-group, so tool_use / tool_result pairs are always complete.
        result = []
        for seq, role, raw_content in reversed(rows):
            if cutoff_seq is not None and seq < cutoff_seq:
@@ -312,6 +343,9 @@ class ConversationStore:
                content = json.loads(raw_content)
            except Exception:
                content = raw_content
+            # Strip thinking blocks — they are stored for UI display only
+            if role == "assistant" and isinstance(content, list):
+                content = [b for b in content if b.get("type") != "thinking"]
            result.append({"role": role, "content": content})
        return result

@@ -389,6 +423,61 @@ class ConversationStore:
                        """,
                        (session_id, session_id),
                    )
+
+                    # Auto-generate title from the first visible user message
+                    cur_title = conn.execute(
+                        "SELECT title FROM sessions WHERE session_id = ?",
+                        (session_id,),
+                    ).fetchone()
+                    if cur_title and not cur_title[0]:
+                        for msg in messages:
+                            if msg.get("role") == "user":
+                                content = msg.get("content", "")
+                                text = _extract_display_text(content)
+                                if text:
+                                    title = text[:50].split("\n")[0]
+                                    conn.execute(
+                                        "UPDATE sessions SET title = ? WHERE session_id = ?",
+                                        (title, session_id),
+                                    )
+                                    break
+            finally:
+                conn.close()
+
+    def clear_context(self, session_id: str) -> int:
+        """
+        Set the context boundary to after the current last message.
+        Messages before this boundary are still stored but excluded from LLM context.
+
+        Returns the new context_start_seq value.
+        """
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    row = conn.execute(
+                        "SELECT COALESCE(MAX(seq), -1) FROM messages WHERE session_id = ?",
+                        (session_id,),
+                    ).fetchone()
+                    new_start = row[0] + 1
+                    conn.execute(
+                        "UPDATE sessions SET context_start_seq = ? WHERE session_id = ?",
+                        (new_start, session_id),
+                    )
+                    return new_start
+            finally:
+                conn.close()
+
+    def get_context_start_seq(self, session_id: str) -> int:
+        """Return the context_start_seq for a session (0 if not set)."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                row = conn.execute(
+                    "SELECT context_start_seq FROM sessions WHERE session_id = ?",
+                    (session_id,),
+                ).fetchone()
+                return row[0] if row else 0
            finally:
                conn.close()

@@ -410,6 +499,7 @@ class ConversationStore:
    def cleanup_old_sessions(self, max_age_days: Optional[int] = None) -> int:
        """
        Delete sessions that have not been active within max_age_days.
+        Web channel sessions are excluded — they are meant to be permanent.

        Args:
            max_age_days: Override the default retention period.
@@ -433,7 +523,8 @@ class ConversationStore:
            try:
                with conn:
                    stale = conn.execute(
-                        "SELECT session_id FROM sessions WHERE last_active < ?",
+                        "SELECT session_id FROM sessions "
+                        "WHERE last_active < ? AND channel_type != 'web'",
                        (cutoff,),
                    ).fetchall()
                    for (sid,) in stale:
@@ -492,9 +583,15 @@ class ConversationStore:
        with self._lock:
            conn = self._connect()
            try:
+                ctx_row = conn.execute(
+                    "SELECT context_start_seq FROM sessions WHERE session_id = ?",
+                    (session_id,),
+                ).fetchone()
+                ctx_start = ctx_row[0] if ctx_row else 0
+
                rows = conn.execute(
                    """
-                    SELECT role, content, created_at
+                    SELECT seq, role, content, created_at
                    FROM messages
                    WHERE session_id = ?
                    ORDER BY seq ASC
@@ -504,7 +601,30 @@ class ConversationStore:
            finally:
                conn.close()

-        visible = _group_into_display_turns(rows)
+        # Strip seq for display grouping, but record max seq per visible user group
+        plain_rows = [(role, content, created_at) for _seq, role, content, created_at in rows]
+        visible = _group_into_display_turns(plain_rows)
+
+        # Build a mapping: find the seq of each visible user message to annotate context boundary.
+        # Walk through rows to find visible user message seqs in order.
+        visible_user_seqs: List[int] = []
+        for seq, role, raw_content, _ts in rows:
+            if role != "user":
+                continue
+            try:
+                content = json.loads(raw_content)
+            except Exception:
+                content = raw_content
+            if _is_visible_user_message(content):
+                visible_user_seqs.append(seq)
+
+        # Each pair of display turns (user+assistant) corresponds to a visible user seq.
+        # Mark which turns are before the context boundary.
+        user_turn_idx = 0
+        for turn in visible:
+            if turn["role"] == "user" and user_turn_idx < len(visible_user_seqs):
+                turn["_seq"] = visible_user_seqs[user_turn_idx]
+                user_turn_idx += 1

        total = len(visible)
        offset = (page - 1) * page_size
@@ -513,12 +633,98 @@ class ConversationStore:

        return {
            "messages": page_items,
+            "context_start_seq": ctx_start,
            "total": total,
            "page": page,
            "page_size": page_size,
            "has_more": offset + page_size < total,
        }

+    def list_sessions(
+        self,
+        channel_type: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 50,
+    ) -> Dict[str, Any]:
+        """
+        List sessions ordered by last_active DESC, with optional channel_type filter.
+
+        Returns:
+            {
+                "sessions": [{session_id, title, created_at, last_active, msg_count}, ...],
+                "total": int,
+                "page": int,
+                "page_size": int,
+                "has_more": bool,
+            }
+        """
+        page = max(1, page)
+        with self._lock:
+            conn = self._connect()
+            try:
+                if channel_type:
+                    total = conn.execute(
+                        "SELECT COUNT(*) FROM sessions WHERE channel_type = ?",
+                        (channel_type,),
+                    ).fetchone()[0]
+                    rows = conn.execute(
+                        """
+                        SELECT session_id, title, created_at, last_active, msg_count
+                        FROM sessions
+                        WHERE channel_type = ?
+                        ORDER BY last_active DESC
+                        LIMIT ? OFFSET ?
+                        """,
+                        (channel_type, page_size, (page - 1) * page_size),
+                    ).fetchall()
+                else:
+                    total = conn.execute(
+                        "SELECT COUNT(*) FROM sessions",
+                    ).fetchone()[0]
+                    rows = conn.execute(
+                        """
+                        SELECT session_id, title, created_at, last_active, msg_count
+                        FROM sessions
+                        ORDER BY last_active DESC
+                        LIMIT ? OFFSET ?
+                        """,
+                        (page_size, (page - 1) * page_size),
+                    ).fetchall()
+            finally:
+                conn.close()
+
+        sessions = [
+            {
+                "session_id": r[0],
+                "title": r[1],
+                "created_at": r[2],
+                "last_active": r[3],
+                "msg_count": r[4],
+            }
+            for r in rows
+        ]
+        return {
+            "sessions": sessions,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "has_more": (page - 1) * page_size + page_size < total,
+        }
+
+    def rename_session(self, session_id: str, title: str) -> bool:
+        """Update the title of a session. Returns True if the session existed."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    cur = conn.execute(
+                        "UPDATE sessions SET title = ? WHERE session_id = ?",
+                        (title, session_id),
+                    )
+                    return cur.rowcount > 0
+            finally:
+                conn.close()
+
    def get_stats(self) -> Dict[str, Any]:
        """Return basic stats keyed by channel_type, for monitoring."""
        with self._lock:
@@ -573,6 +779,20 @@ class ConversationStore:
                logger.info("[ConversationStore] Migrated: added channel_type column")
            except Exception as e:
                logger.warning(f"[ConversationStore] Migration failed: {e}")
+        if "title" not in cols:
+            try:
+                conn.execute(_MIGRATION_ADD_TITLE)
+                conn.commit()
+                logger.info("[ConversationStore] Migrated: added title column")
+            except Exception as e:
+                logger.warning(f"[ConversationStore] Migration (title) failed: {e}")
+        if "context_start_seq" not in cols:
+            try:
+                conn.execute(_MIGRATION_ADD_CONTEXT_START_SEQ)
+                conn.commit()
+                logger.info("[ConversationStore] Migrated: added context_start_seq column")
+            except Exception as e:
+                logger.warning(f"[ConversationStore] Migration (context_start_seq) failed: {e}")

    def _connect(self) -> sqlite3.Connection:
        conn = sqlite3.connect(str(self._db_path), timeout=10)
--- a/agent/memory/manager.py
+++ b/agent/memory/manager.py
@@ -285,6 +285,10 @@ class MemoryManager:
        # Scan memory directory (including daily summaries)
        if memory_dir.exists():
            for file_path in memory_dir.rglob("*.md"):
+                # Skip hidden directories (e.g. .dreams/)
+                if any(part.startswith('.') for part in file_path.relative_to(workspace_dir).parts):
+                    continue
+
                # Determine scope and user_id from path
                rel_path = file_path.relative_to(workspace_dir)
                parts = rel_path.parts
@@ -312,6 +316,14 @@ class MemoryManager:
                    scope = "shared"
                
                await self._sync_file(file_path, "memory", scope, user_id)
+
+        # Scan knowledge directory (structured knowledge wiki)
+        from config import conf
+        if conf().get("knowledge", True):
+            knowledge_dir = Path(workspace_dir) / "knowledge"
+            if knowledge_dir.exists():
+                for file_path in knowledge_dir.rglob("*.md"):
+                    await self._sync_file(file_path, "knowledge", "shared", None)
        
        self._dirty = False
    
@@ -389,24 +401,28 @@ class MemoryManager:
        user_id: Optional[str] = None,
        reason: str = "threshold",
        max_messages: int = 10,
+        context_summary_callback=None,
    ) -> bool:
        """
        Flush conversation summary to daily memory file.
-        
+
        Args:
            messages: Conversation message list
            user_id: Optional user ID
            reason: "threshold" | "overflow" | "daily_summary"
            max_messages: Max recent messages to include (0 = all)
-        
+            context_summary_callback: Optional callback(str) invoked with the
+                daily summary text for in-context injection
+
        Returns:
-            True if content was written
+            True if flush was dispatched
        """
        success = self.flush_manager.flush_from_messages(
            messages=messages,
            user_id=user_id,
            reason=reason,
            max_messages=max_messages,
+            context_summary_callback=context_summary_callback,
        )
        if success:
            self._dirty = True
--- a/agent/memory/service.py
+++ b/agent/memory/service.py
@@ -32,68 +32,80 @@ class MemoryService:
    # ------------------------------------------------------------------
    # list — paginated file metadata
    # ------------------------------------------------------------------
-    def list_files(self, page: int = 1, page_size: int = 20) -> dict:
+    def list_files(self, page: int = 1, page_size: int = 20, category: str = "memory") -> dict:
        """
-        List all memory files with metadata (without content).
+        List memory or dream files with metadata (without content).

-        Returns::
-
-            {
-                "page": 1,
-                "page_size": 20,
-                "total": 15,
-                "list": [
-                    {"filename": "MEMORY.md", "type": "global", "size": 2048, "updated_at": "2026-02-20 10:00:00"},
-                    {"filename": "2026-02-20.md", "type": "daily", "size": 512, "updated_at": "2026-02-20 09:30:00"},
-                    ...
-                ]
-            }
+        Args:
+            category: ``"memory"`` (default) — MEMORY.md + daily files;
+                      ``"dream"``  — dream diary files from memory/dreams/
        """
+        if category == "dream":
+            files = self._list_dream_files()
+        else:
+            files = self._list_memory_files()
+
+        total = len(files)
+        start = (page - 1) * page_size
+        end = start + page_size
+
+        return {
+            "page": page,
+            "page_size": page_size,
+            "total": total,
+            "list": files[start:end],
+        }
+
+    def _list_memory_files(self) -> List[dict]:
+        """MEMORY.md + memory/*.md (newest first)."""
        files: List[dict] = []

-        # 1. Global memory — MEMORY.md in workspace root
        global_path = os.path.join(self.workspace_root, "MEMORY.md")
        if os.path.isfile(global_path):
            files.append(self._file_info(global_path, "MEMORY.md", "global"))

-        # 2. Daily memory files — memory/*.md (sorted newest first)
        if os.path.isdir(self.memory_dir):
            daily_files = []
            for name in os.listdir(self.memory_dir):
                full = os.path.join(self.memory_dir, name)
                if os.path.isfile(full) and name.endswith(".md"):
                    daily_files.append((name, full))
-            # Sort by filename descending (newest date first)
            daily_files.sort(key=lambda x: x[0], reverse=True)
            for name, full in daily_files:
                files.append(self._file_info(full, name, "daily"))

-        total = len(files)
+        return files

-        # Paginate
-        start = (page - 1) * page_size
-        end = start + page_size
-        page_items = files[start:end]
+    def _list_dream_files(self) -> List[dict]:
+        """memory/dreams/*.md (newest first)."""
+        files: List[dict] = []
+        dreams_dir = os.path.join(self.memory_dir, "dreams")

-        return {
-            "page": page,
-            "page_size": page_size,
-            "total": total,
-            "list": page_items,
-        }
+        if os.path.isdir(dreams_dir):
+            entries = []
+            for name in os.listdir(dreams_dir):
+                full = os.path.join(dreams_dir, name)
+                if os.path.isfile(full) and name.endswith(".md"):
+                    entries.append((name, full))
+            entries.sort(key=lambda x: x[0], reverse=True)
+            for name, full in entries:
+                files.append(self._file_info(full, name, "dream"))
+
+        return files

    # ------------------------------------------------------------------
    # content — read a single file
    # ------------------------------------------------------------------
-    def get_content(self, filename: str) -> dict:
+    def get_content(self, filename: str, category: str = "memory") -> dict:
        """
-        Read the full content of a memory file.
+        Read the full content of a memory or dream file.

-        :param filename: File name, e.g. ``MEMORY.md`` or ``2026-02-20.md``
+        :param filename: File name, e.g. ``MEMORY.md``, ``2026-02-20.md``
+        :param category: ``"memory"`` or ``"dream"``
        :return: dict with ``filename`` and ``content``
        :raises FileNotFoundError: if the file does not exist
        """
-        path = self._resolve_path(filename)
+        path = self._resolve_path(filename, category)
        if not os.path.isfile(path):
            raise FileNotFoundError(f"Memory file not found: {filename}")

@@ -113,7 +125,7 @@ class MemoryService:
        Dispatch a memory management action.

        :param action: ``list`` or ``content``
-        :param payload: action-specific payload
+        :param payload: action-specific payload (supports ``category``: ``"memory"`` | ``"dream"``)
        :return: protocol-compatible response dict
        """
        payload = payload or {}
@@ -121,19 +133,23 @@ class MemoryService:
            if action == "list":
                page = payload.get("page", 1)
                page_size = payload.get("page_size", 20)
-                result_payload = self.list_files(page=page, page_size=page_size)
+                category = payload.get("category", "memory")
+                result_payload = self.list_files(page=page, page_size=page_size, category=category)
                return {"action": action, "code": 200, "message": "success", "payload": result_payload}

            elif action == "content":
                filename = payload.get("filename")
                if not filename:
                    return {"action": action, "code": 400, "message": "filename is required", "payload": None}
-                result_payload = self.get_content(filename)
+                category = payload.get("category", "memory")
+                result_payload = self.get_content(filename, category=category)
                return {"action": action, "code": 200, "message": "success", "payload": result_payload}

            else:
                return {"action": action, "code": 400, "message": f"unknown action: {action}", "payload": None}

+        except ValueError as e:
+            return {"action": action, "code": 403, "message": "invalid filename", "payload": None}
        except FileNotFoundError as e:
            return {"action": action, "code": 404, "message": str(e), "payload": None}
        except Exception as e:
@@ -143,16 +159,30 @@ class MemoryService:
    # ------------------------------------------------------------------
    # internal helpers
    # ------------------------------------------------------------------
-    def _resolve_path(self, filename: str) -> str:
+    def _resolve_path(self, filename: str, category: str = "memory") -> str:
        """
-        Resolve a filename to its absolute path.
+        Safely resolve a filename to its absolute path within the allowed directory.

        - ``MEMORY.md`` → ``{workspace_root}/MEMORY.md``
-        - ``2026-02-20.md`` → ``{workspace_root}/memory/2026-02-20.md``
+        - ``2026-02-20.md`` (memory) → ``{workspace_root}/memory/2026-02-20.md``
+        - ``2026-02-20.md`` (dream) → ``{workspace_root}/memory/dreams/2026-02-20.md``
+
+        Raises ValueError if the resolved path escapes the allowed directory.
        """
        if filename == "MEMORY.md":
-            return os.path.join(self.workspace_root, filename)
-        return os.path.join(self.memory_dir, filename)
+            base_dir = self.workspace_root
+        elif category == "dream":
+            base_dir = os.path.join(self.memory_dir, "dreams")
+        else:
+            base_dir = self.memory_dir
+
+        resolved = os.path.realpath(os.path.join(base_dir, filename))
+        allowed = os.path.realpath(base_dir)
+
+        if resolved != allowed and not resolved.startswith(allowed + os.sep):
+            raise ValueError(f"Invalid filename: path traversal detected")
+
+        return resolved

    @staticmethod
    def _file_info(path: str, filename: str, file_type: str) -> dict:
--- a/agent/memory/summarizer.py
+++ b/agent/memory/summarizer.py
@@ -1,12 +1,12 @@
 """
-Memory flush manager
+Memory flush manager with Deep Dream distillation

 Handles memory persistence when conversation context is trimmed or overflows:
- Uses LLM to summarize discarded messages into concise key-information entries
+- Uses LLM to summarize discarded messages into concise daily records
 - Writes to daily memory files (lazy creation)
 - Deduplicates trim flushes to avoid repeated writes
 - Runs summarization asynchronously to avoid blocking normal replies
- Provides daily summary interface for scheduler
+- Deep Dream: periodically distills daily memories → refined MEMORY.md + dream diary
 """

 import threading
@@ -16,19 +16,78 @@ from datetime import datetime
 from common.log import logger


-SUMMARIZE_SYSTEM_PROMPT = """你是一个记忆提取助手。你的任务是从对话记录中提取值得记住的信息，生成简洁的记忆摘要。
+SUMMARIZE_SYSTEM_PROMPT = """你是一个对话记录助手。请将对话内容归纳为当天的日常记录。

-输出要求：
-1. 以事件/关键信息为维度记录，每条一行，用 "- " 开头
-2. 记录有价值的关键信息，例如用户提出的要求及助手的解决方案，对话中涉及的事实信息，用户的偏好、决策或重要结论
-3. 每条摘要需要简明扼要，只保留关键信息
-4. 直接输出摘要内容，不要加任何前缀说明
-5. 当对话没有任何记录价值例如只是简单问候，可回复"无\""""
+## 要求

-SUMMARIZE_USER_PROMPT = """请从以下对话记录中提取关键信息，生成记忆摘要：
+按「事件」维度归纳发生的事，不要按对话轮次逐条记录：
+- 每条一行，用 "- " 开头
+- 合并同一件事的多轮对话
+- 只记录有意义的事件，忽略闲聊和问候
+- 保留关键的决策、结论和待办事项
+
+当对话没有任何记录价值（仅含问候或无意义内容），直接回复"无"。"""
+
+SUMMARIZE_USER_PROMPT = """请归纳以下对话的日常记录：

 {conversation}"""

+# ---------------------------------------------------------------------------
+# Deep Dream prompts — distill daily memories → MEMORY.md + dream diary
+# ---------------------------------------------------------------------------
+
+DREAM_SYSTEM_PROMPT = """你是一个记忆整理助手，负责定期整理用户的长期记忆。
+
+你将收到两份材料：
+1. **当前长期记忆** — MEMORY.md 的全部现有内容
+2. **今日日记** — 当天的日常记录
+
+MEMORY.md 会注入每次对话的系统提示词中，因此必须保持精炼，只存放有价值和值得记忆的内容。
+
+**重要：只能基于提供的材料进行整理，严禁编造、推测或添加材料中不存在的信息。**
+
+## 任务
+
+### Part 1: 更新后的长期记忆（[MEMORY]）
+
+在现有记忆基础上进行整理和提炼，输出完整的更新后内容：
+- **合并提炼**：将含义相近的多条合并为一条高密度表述，而非简单罗列
+- **新增萃取**：从今日日记中提取值得永久记住的新信息（偏好、决策、人物、规则、经验）
+- **冲突更新**：当新信息与旧条目矛盾时，以新信息为准，替换旧条目
+- **清理无效**：删除临时性记录、空白条目、格式残留、无意义、重复内容等
+- **删除冗余**：已被更精炼表述涵盖的旧条目应删除，避免信息重复
+- 每条一行，用 "- " 开头，不带日期前缀
+- 目标：控制在 50 条以内，每条尽量一句话概括
+
+### Part 2: 梦境日记（[DREAM]）
+
+用简洁的叙事风格写一篇短日记，记录这次整理的发现，保持格式美观易读：
+- 发现了哪些重复或矛盾
+- 从日记中提取了什么新洞察
+- 做了哪些清理和优化
+- 整体感受和观察
+
+## 输出格式（严格遵守）
+
+```
+[MEMORY]
+- 记忆条目1
+- 记忆条目2
+...
+
+[DREAM]
+梦境日记内容...
+```"""
+
+DREAM_USER_PROMPT = """## 当前长期记忆（MEMORY.md）
+
+{memory_content}
+
+## 近期日记（最近 {days} 天）
+
+{daily_content}"""
+
+

 class MemoryFlushManager:
    """
@@ -55,6 +114,8 @@ class MemoryFlushManager:
        self.last_flush_timestamp: Optional[datetime] = None
        self._trim_flushed_hashes: set = set()  # Content hashes of already-flushed messages
        self._last_flushed_content_hash: str = ""  # Content hash at last flush, for daily dedup
+        self._last_dream_input_hash: str = ""  # Hash of dream input, for dedup
+        self._last_flush_thread: Optional[threading.Thread] = None
    
    def get_today_memory_file(self, user_id: Optional[str] = None, ensure_exists: bool = False) -> Path:
        """Get today's memory file path: memory/YYYY-MM-DD.md"""
@@ -98,21 +159,19 @@ class MemoryFlushManager:
        user_id: Optional[str] = None,
        reason: str = "trim",
        max_messages: int = 0,
+        context_summary_callback: Optional[Callable[[str], None]] = None,
    ) -> bool:
        """
        Asynchronously summarize and flush messages to daily memory.
-        
+
        Deduplication runs synchronously, then LLM summarization + file write
        run in a background thread so the main reply flow is never blocked.
-        
-        Args:
-            messages: Conversation message list (OpenAI/Claude format)
-            user_id: Optional user ID for user-scoped memory
-            reason: Why flush was triggered ("trim" | "overflow" | "daily_summary")
-            max_messages: Max recent messages to summarize (0 = all)
-        
-        Returns:
-            True if flush was dispatched
+
+        If *context_summary_callback* is provided, it is called with the
+        [DAILY] portion of the LLM summary once available. The caller can use
+        this to inject the summary into the live message list for context
+        continuity — one LLM call serves both disk persistence and in-context
+        injection.
        """
        try:
            import hashlib
@@ -127,18 +186,19 @@ class MemoryFlushManager:
                    deduped.append(m)
            if not deduped:
                return False
-            
+
            import copy
            snapshot = copy.deepcopy(deduped)
            thread = threading.Thread(
                target=self._flush_worker,
-                args=(snapshot, user_id, reason, max_messages),
+                args=(snapshot, user_id, reason, max_messages, context_summary_callback),
                daemon=True,
            )
            thread.start()
            logger.info(f"[MemoryFlush] Async flush dispatched (reason={reason}, msgs={len(snapshot)})")
+            self._last_flush_thread = thread
            return True
-            
+
        except Exception as e:
            logger.warning(f"[MemoryFlush] Failed to dispatch flush (reason={reason}): {e}")
            return False
@@ -149,41 +209,69 @@ class MemoryFlushManager:
        user_id: Optional[str],
        reason: str,
        max_messages: int,
+        context_summary_callback: Optional[Callable[[str], None]] = None,
    ):
-        """Background worker: summarize with LLM and write to daily file."""
+        """Background worker: summarize with LLM, write daily memory file."""
        try:
-            summary = self._summarize_messages(messages, max_messages)
-            if not summary or not summary.strip() or summary.strip() == "无":
+            raw_summary = self._summarize_messages(messages, max_messages)
+            if not raw_summary or not raw_summary.strip() or raw_summary.strip() == "无":
                logger.info(f"[MemoryFlush] No valuable content to flush (reason={reason})")
                return
-            
+
+            # Strip legacy [DAILY]/[MEMORY] markers if model still outputs them
+            daily_part = self._clean_summary_output(raw_summary)
+            if not daily_part:
+                return
+
+            # --- Write daily memory ---
            daily_file = ensure_daily_memory_file(self.workspace_dir, user_id)
-            
-            if reason == "overflow":
-                header = f"## Context Overflow Recovery ({datetime.now().strftime('%H:%M')})"
-                note = "The following conversation was trimmed due to context overflow:\n"
-            elif reason == "trim":
-                header = f"## Trimmed Context ({datetime.now().strftime('%H:%M')})"
-                note = ""
-            elif reason == "daily_summary":
-                header = f"## Daily Summary ({datetime.now().strftime('%H:%M')})"
-                note = ""
-            else:
-                header = f"## Session Notes ({datetime.now().strftime('%H:%M')})"
-                note = ""
-            
-            flush_entry = f"\n{header}\n\n{note}{summary}\n"
-            
+
+            headers = {
+                "overflow": f"## Context Overflow Recovery ({datetime.now().strftime('%H:%M')})",
+                "trim": f"## Trimmed Context ({datetime.now().strftime('%H:%M')})",
+                "daily_summary": f"## Daily Summary ({datetime.now().strftime('%H:%M')})",
+            }
+            header = headers.get(reason, f"## Session Notes ({datetime.now().strftime('%H:%M')})")
+
            with open(daily_file, "a", encoding="utf-8") as f:
-                f.write(flush_entry)
-            
+                f.write(f"\n{header}\n\n{daily_part}\n")
+
+            logger.info(f"[MemoryFlush] Wrote daily memory to {daily_file.name} (reason={reason}, chars={len(daily_part)})")
+
+            # --- Inject context summary into live messages (if callback provided) ---
+            if context_summary_callback:
+                try:
+                    context_summary_callback(daily_part)
+                except Exception as e:
+                    logger.warning(f"[MemoryFlush] Context summary callback failed: {e}")
+
            self.last_flush_timestamp = datetime.now()
-            
-            logger.info(f"[MemoryFlush] Wrote to {daily_file.name} (reason={reason}, chars={len(summary)})")
-            
+
        except Exception as e:
            logger.warning(f"[MemoryFlush] Async flush failed (reason={reason}): {e}")
-    
+
+    @staticmethod
+    def _clean_summary_output(raw: str) -> str:
+        """Strip legacy [DAILY]/[MEMORY] markers if present, return clean daily text."""
+        raw = raw.strip()
+        if not raw or raw == "无":
+            return ""
+
+        # Strip [DAILY] marker
+        if "[DAILY]" in raw:
+            start = raw.index("[DAILY]") + len("[DAILY]")
+            end = raw.index("[MEMORY]") if "[MEMORY]" in raw else len(raw)
+            raw = raw[start:end].strip()
+
+        # Remove stray [MEMORY] section entirely
+        if "[MEMORY]" in raw:
+            raw = raw[:raw.index("[MEMORY]")].strip()
+
+        # Remove markdown code fences
+        raw = raw.replace("```", "").strip()
+
+        return raw
+
    def create_daily_summary(
        self,
        messages: List[Dict],
@@ -209,27 +297,205 @@ class MemoryFlushManager:
            reason="daily_summary",
            max_messages=0,
        )
-    
+
+    # ---- Deep Dream (memory distillation) ----
+
+    def deep_dream(self, user_id: Optional[str] = None, lookback_days: int = 1, force: bool = False) -> bool:
+        """
+        Distill recent daily memories into MEMORY.md and generate a dream diary.
+
+        Args:
+            lookback_days: How many days of daily files to read (default 1 for scheduled, 3 for manual)
+            force: Skip input-hash dedup check (used by manual /memory dream trigger)
+        """
+        if not self.llm_model:
+            logger.warning("[DeepDream] No LLM model available, skipping")
+            return False
+
+        logger.info(f"[DeepDream] Starting memory distillation (lookback={lookback_days} days)")
+
+        # Collect materials
+        memory_content = self._read_main_memory(user_id)
+        daily_content, has_content = self._read_recent_dailies(user_id, lookback_days)
+
+        if not has_content:
+            logger.info("[DeepDream] No recent daily records, skipping to preserve existing MEMORY.md")
+            return False
+
+        # Dedup: skip if input materials haven't changed since last dream
+        import hashlib
+        input_hash = hashlib.md5((memory_content + daily_content).encode("utf-8")).hexdigest()
+        if not force and input_hash == self._last_dream_input_hash:
+            logger.debug("[DeepDream] Input unchanged since last dream, skipping")
+            return False
+        self._last_dream_input_hash = input_hash
+
+        logger.info(
+            f"[DeepDream] Materials collected: "
+            f"MEMORY.md={len(memory_content)} chars, "
+            f"daily={len(daily_content)} chars"
+        )
+
+        # Call LLM for distillation
+        import time as _time
+        t0 = _time.monotonic()
+        try:
+            user_msg = DREAM_USER_PROMPT.format(
+                memory_content=memory_content or "(empty)",
+                days=lookback_days,
+                daily_content=daily_content or "(no recent daily records)",
+            )
+            from agent.protocol.models import LLMRequest
+            # Scale max_tokens based on input size to avoid truncating large MEMORY.md
+            input_chars = len(memory_content) + len(daily_content)
+            dream_max_tokens = max(2000, min(input_chars, 8000))
+            request = LLMRequest(
+                messages=[{"role": "user", "content": user_msg}],
+                temperature=0.3,
+                max_tokens=dream_max_tokens,
+                stream=False,
+                system=DREAM_SYSTEM_PROMPT,
+            )
+            response = self.llm_model.call(request)
+            raw = self._extract_response_text(response)
+            elapsed = _time.monotonic() - t0
+            if not raw or not raw.strip():
+                logger.warning(f"[DeepDream] LLM returned empty response ({elapsed:.1f}s)")
+                return False
+            logger.info(f"[DeepDream] LLM distillation completed ({elapsed:.1f}s, {len(raw)} chars)")
+        except Exception as e:
+            elapsed = _time.monotonic() - t0
+            logger.warning(f"[DeepDream] LLM call failed ({elapsed:.1f}s): {e}")
+            return False
+
+        # Parse [MEMORY] and [DREAM] sections
+        new_memory, dream_diary = self._parse_dream_output(raw)
+
+        if not new_memory:
+            logger.warning("[DeepDream] No [MEMORY] section in LLM output, skipping overwrite")
+            return False
+
+        # Overwrite MEMORY.md
+        try:
+            main_file = self.get_main_memory_file(user_id)
+            old_size = len(memory_content)
+            main_file.write_text(new_memory + "\n", encoding="utf-8")
+            logger.info(
+                f"[DeepDream] Updated MEMORY.md "
+                f"({old_size} → {len(new_memory)} chars)"
+            )
+        except Exception as e:
+            logger.warning(f"[DeepDream] Failed to write MEMORY.md: {e}")
+            return False
+
+        # Write dream diary
+        if dream_diary:
+            try:
+                self._write_dream_diary(dream_diary, user_id)
+            except Exception as e:
+                logger.warning(f"[DeepDream] Failed to write dream diary: {e}")
+
+        logger.info("[DeepDream] ✅ Deep Dream completed successfully")
+        return True
+
+    def _read_main_memory(self, user_id: Optional[str] = None) -> str:
+        """Read current MEMORY.md content."""
+        main_file = self.get_main_memory_file(user_id)
+        if main_file.exists():
+            return main_file.read_text(encoding="utf-8").strip()
+        return ""
+
+    def _read_recent_dailies(
+        self, user_id: Optional[str] = None, lookback_days: int = 1
+    ) -> tuple:
+        """
+        Read recent daily memory files.
+
+        Returns:
+            (combined_text, has_content) tuple
+        """
+        from datetime import timedelta
+
+        parts = []
+        has_content = False
+        today = datetime.now().date()
+
+        for offset in range(lookback_days):
+            day = today - timedelta(days=offset)
+            date_str = day.strftime("%Y-%m-%d")
+            if user_id:
+                daily_file = self.memory_dir / "users" / user_id / f"{date_str}.md"
+            else:
+                daily_file = self.memory_dir / f"{date_str}.md"
+
+            if daily_file.exists():
+                content = daily_file.read_text(encoding="utf-8").strip()
+                if content:
+                    parts.append(f"### {date_str}\n\n{content}")
+                    has_content = True
+            else:
+                parts.append(f"### {date_str}\n\n(no records)")
+
+        return "\n\n".join(parts), has_content
+
+    @staticmethod
+    def _parse_dream_output(raw: str) -> tuple:
+        """Parse LLM output into (new_memory, dream_diary)."""
+        raw = raw.strip().replace("```", "")
+        new_memory = ""
+        dream_diary = ""
+
+        if "[MEMORY]" in raw:
+            start = raw.index("[MEMORY]") + len("[MEMORY]")
+            end = raw.index("[DREAM]") if "[DREAM]" in raw else len(raw)
+            new_memory = raw[start:end].strip()
+
+        if "[DREAM]" in raw:
+            start = raw.index("[DREAM]") + len("[DREAM]")
+            dream_diary = raw[start:].strip()
+
+        return new_memory, dream_diary
+
+    def _write_dream_diary(self, content: str, user_id: Optional[str] = None):
+        """Write dream diary to memory/dreams/YYYY-MM-DD.md."""
+        dreams_dir = self.memory_dir / "dreams"
+        if user_id:
+            dreams_dir = self.memory_dir / "users" / user_id / "dreams"
+        dreams_dir.mkdir(parents=True, exist_ok=True)
+
+        today = datetime.now().strftime("%Y-%m-%d")
+        diary_file = dreams_dir / f"{today}.md"
+        diary_file.write_text(
+            f"# Dream Diary: {today}\n\n{content}\n",
+            encoding="utf-8",
+        )
+        logger.info(f"[DeepDream] Wrote dream diary to {diary_file}")
+
    # ---- Internal helpers ----
    
    def _summarize_messages(self, messages: List[Dict], max_messages: int = 0) -> str:
        """
-        Summarize conversation messages using LLM, with rule-based fallback.
+        Summarize conversation messages using LLM.
+        Returns empty string if LLM deems content not worth recording.
+        Rule-based fallback only used when LLM call raises an exception.
        """
        conversation_text = self._format_conversation_for_summary(messages, max_messages)
        if not conversation_text.strip():
            return ""
        
-        # Try LLM summarization first
        if self.llm_model:
            try:
                summary = self._call_llm_for_summary(conversation_text)
                if summary and summary.strip() and summary.strip() != "无":
                    return summary.strip()
+                logger.info("[MemoryFlush] LLM returned empty or '无', skipping write")
+                return ""
            except Exception as e:
                logger.warning(f"[MemoryFlush] LLM summarization failed, using fallback: {e}")
-        
-        return self._extract_summary_fallback(messages, max_messages)
+                return self._extract_summary_fallback(messages, max_messages)
+        else:
+            logger.info("[MemoryFlush] No LLM model available, using rule-based fallback")
+            return self._extract_summary_fallback(messages, max_messages)

    def _format_conversation_for_summary(self, messages: List[Dict], max_messages: int = 0) -> str:
        """Format messages into readable conversation text for LLM summarization."""
@@ -247,6 +513,52 @@ class MemoryFlushManager:
                lines.append(f"助手: {text[:500]}")
        return "\n".join(lines)

+    @staticmethod
+    def _extract_response_text(response) -> str:
+        """
+        Extract text from LLM response regardless of format.
+
+        Handles:
+        - Generator (MiniMax _handle_sync_response yields Claude-format dicts)
+        - Claude format: {"role":"assistant","content":[{"type":"text","text":"..."}]}
+        - OpenAI format: {"choices":[{"message":{"content":"..."}}]}
+        - OpenAI SDK response object with .choices attribute
+        """
+        import types
+
+        # Unwrap generator — consume first yielded item
+        if isinstance(response, types.GeneratorType):
+            try:
+                response = next(response)
+            except StopIteration:
+                return ""
+
+        if not response:
+            return ""
+
+        if isinstance(response, dict):
+            # Check for error
+            if response.get("error"):
+                raise RuntimeError(response.get("message", "LLM call failed"))
+
+            # Claude format: content is a list of blocks
+            content = response.get("content")
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        return block.get("text", "")
+
+            # OpenAI format
+            choices = response.get("choices", [])
+            if choices:
+                return choices[0].get("message", {}).get("content", "")
+
+        # OpenAI SDK response object
+        if hasattr(response, "choices") and response.choices:
+            return response.choices[0].message.content or ""
+
+        return ""
+
    def _call_llm_for_summary(self, conversation_text: str) -> str:
        """Call LLM to generate a concise summary of the conversation."""
        from agent.protocol.models import LLMRequest
@@ -260,44 +572,59 @@ class MemoryFlushManager:
        )
        
        response = self.llm_model.call(request)
-        
-        if isinstance(response, dict):
-            if response.get("error"):
-                raise RuntimeError(response.get("message", "LLM call failed"))
-            # OpenAI format
-            choices = response.get("choices", [])
-            if choices:
-                return choices[0].get("message", {}).get("content", "")
-        
-        # Handle response object with attribute access (e.g. OpenAI SDK response)
-        if hasattr(response, "choices") and response.choices:
-            return response.choices[0].message.content or ""
-        
-        return ""
+        return self._extract_response_text(response)
+
+    @staticmethod
+    def _extract_first_meaningful_line(text: str, max_len: int = 120) -> str:
+        """Extract the first meaningful line from assistant reply, skipping markdown noise."""
+        import re
+        for line in text.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            # Skip markdown headings, horizontal rules, code fences, pure emoji/symbols
+            if re.match(r'^(#{1,4}\s|```|---|\*\*\*|[-*]\s*$|[^\w\u4e00-\u9fff]{1,5}$)', line):
+                continue
+            # Strip leading markdown bold/emoji decorations
+            cleaned = re.sub(r'^[\*#>\-\s]+', '', line).strip()
+            cleaned = re.sub(r'^[\U0001f300-\U0001f9ff\u2600-\u27bf\s]+', '', cleaned).strip()
+            if len(cleaned) >= 5:
+                return cleaned[:max_len]
+        return text.split("\n")[0].strip()[:max_len]

    @staticmethod
    def _extract_summary_fallback(messages: List[Dict], max_messages: int = 0) -> str:
-        """Rule-based fallback when LLM is unavailable."""
+        """
+        Rule-based summary of discarded messages.
+        Format: "用户问了X; 助手回答了Y" per event, compact and readable.
+        """
        msgs = messages if max_messages == 0 else messages[-max_messages * 2:]
-        
-        items = []
+
+        events: List[str] = []
+        current_user_text = ""
        for msg in msgs:
            role = msg.get("role", "")
            text = MemoryFlushManager._extract_text_from_content(msg.get("content", ""))
            if not text or not text.strip():
                continue
            text = text.strip()
-            
+
            if role == "user":
-                if len(text) <= 5:
+                if len(text) <= 3:
                    continue
-                items.append(f"- 用户请求: {text[:200]}")
-            elif role == "assistant":
-                first_line = text.split("\n")[0].strip()
-                if len(first_line) > 10:
-                    items.append(f"- 处理结果: {first_line[:200]}")
-        
-        return "\n".join(items[:15])
+                current_user_text = text[:120]
+            elif role == "assistant" and current_user_text:
+                reply_summary = MemoryFlushManager._extract_first_meaningful_line(text)
+                if reply_summary:
+                    events.append(f"- 用户: {current_user_text} → 回复: {reply_summary}")
+                else:
+                    events.append(f"- 用户: {current_user_text}")
+                current_user_text = ""
+
+        if current_user_text:
+            events.append(f"- 用户: {current_user_text}")
+
+        return "\n".join(events[:10])
    
    @staticmethod
    def _extract_text_from_content(content) -> str:
--- a/agent/prompt/builder.py
+++ b/agent/prompt/builder.py
@@ -10,6 +10,7 @@ from typing import List, Dict, Optional, Any
 from dataclasses import dataclass

 from common.log import logger
+from config import conf


@dataclass
@@ -92,10 +93,11 @@ def build_agent_system_prompt(
    顺序说明（按重要性和逻辑关系排列）:
    1. 工具系统 - 核心能力，最先介绍
    2. 技能系统 - 紧跟工具，因为技能需要用 read 工具读取
-    3. 记忆系统 - 独立的记忆能力
+    3. 记忆系统 - 记忆检索与写入引导
+    3.5 知识系统 - 结构化知识库（knowledge/index.md 注入）
    4. 工作空间 - 工作环境说明
    5. 用户身份 - 用户信息（可选）
-    6. 项目上下文 - AGENT.md, USER.md, RULE.md, BOOTSTRAP.md（定义人格、身份、规则、初始化引导）
+    6. 项目上下文 - AGENT.md, USER.md, RULE.md, MEMORY.md, BOOTSTRAP.md
    7. 运行时信息 - 元信息（时间、模型等）
    
    Args:
@@ -126,6 +128,10 @@ def build_agent_system_prompt(
    # 3. 记忆系统（独立的记忆能力）
    if memory_manager:
        sections.extend(_build_memory_section(memory_manager, tools, language))
+
+    # 3.5 知识系统（结构化知识库）
+    if conf().get("knowledge", True):
+        sections.extend(_build_knowledge_section(workspace_dir, language))
    
    # 4. 工作空间（工作环境说明）
    sections.extend(_build_workspace_section(workspace_dir, language))
@@ -165,12 +171,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 +186,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
@@ -206,9 +213,9 @@ def _build_tooling_section(tools: List[Any], language: str) -> List[str]:
        "",
        "工具调用风格：",
        "",
-        "- 在多步骤任务、敏感操作或用户要求时简要解释决策过程",
-        "- 持续推进直到任务完成，完成后向用户报告结果。",
-        "- 回复中涉及密钥、令牌等敏感信息必须脱敏。",
+        "- 多步骤任务、复杂决策、敏感操作时，应简要说明当前在做什么、为什么这样做，让用户了解关键进展",
+        "- 持续推进直到任务完成，完成后向用户报告结果",
+        "- 回复中涉及密钥、令牌等敏感信息必须脱敏",
        "- URL链接直接放在回复文本中即可，系统会自动处理和渲染。无需下载后使用send工具发送",
        "",
    ]
@@ -267,55 +274,105 @@ def _build_memory_section(memory_manager: Any, tools: Optional[List[Any]], langu
    """构建记忆系统section"""
    if not memory_manager:
        return []
-    
-    # 检查是否有memory工具
+
    has_memory_tools = False
    if tools:
        tool_names = [tool.name if hasattr(tool, 'name') else str(tool) for tool in tools]
        has_memory_tools = any(name in ['memory_search', 'memory_get'] for name in tool_names)
-    
+
    if not has_memory_tools:
        return []
-    
+
    from datetime import datetime
    today_file = datetime.now().strftime("%Y-%m-%d") + ".md"
-    
+
    lines = [
        "## 🧠 记忆系统",
        "",
-        "### 检索记忆",
+        "### Memory Recall（mandatory）",
        "",
-        "在回答关于以前的工作、决定、日期、人物、偏好或待办事项的任何问题之前：",
+        "当用户询问过往事件、引用之前的决定、提到人物关系、偏好、待办、或你对某事不确定时，**必须先检索记忆再回答**。",
+        "如果 MEMORY.md 中已有相关信息则无需重复检索。完整内容和每日记忆需要通过工具检索。",
        "",
-        "1. 不确定记忆文件位置 → 先用 `memory_search` 通过关键词和语义检索相关内容",
-        "2. 已知文件位置 → 直接用 `memory_get` 读取相应的行 (例如：MEMORY.md, memory/YYYY-MM-DD.md)",
-        "3. search 无结果 → 尝试用 `memory_get` 读取MEMORY.md及最近两天记忆文件",
+        "1. 不确定位置 → `memory_search` 关键词/语义检索",
+        "2. 已知位置 → `memory_get` 直接读取对应行",
+        "3. search 无结果 → `memory_get` 读最近两天记忆",
        "",
        "**记忆文件结构**:",
-        f"- `MEMORY.md`: 长期记忆（核心信息、偏好、决策等）",
+        "- `MEMORY.md`: 长期记忆索引（已自动加载到上下文，核心信息、偏好、决策等）",
        f"- `memory/YYYY-MM-DD.md`: 每日记忆，今天是 `memory/{today_file}`",
+        "- `knowledge/`: 结构化知识库（见下方知识系统）",
        "",
        "### 写入记忆",
        "",
-        "**主动存储**：遇到以下情况时，应主动将信息写入记忆文件（无需告知用户）：",
+        "遇到以下情况时，**主动**将信息写入记忆文件（无需告知用户）：",
        "",
-        "- 用户明确要求你记住某些信息",
+        "- 用户要求记住某些信息，或使用了「记住」「以后」「总是」「不要」「偏好」等表达",
        "- 用户分享了重要的个人偏好、习惯、决策",
        "- 对话中产生了重要的结论、方案、约定",
        "- 完成了复杂任务，值得记录关键步骤和结果",
-        "- 发现了用户经常遇到的问题或解决方案",
        "",
        "**存储规则**:",
-        f"- 长期有效的核心信息 → `MEMORY.md`（文件保持精简，< 2000 tokens）",
-        f"- 当天的事件、进展、笔记 → `memory/{today_file}`",
-        "- 追加内容 → `edit` 工具，oldText 留空",
-        "- 修改内容 → `edit` 工具，oldText 填写要替换的文本",
-        "- **禁止写入敏感信息**：API密钥、令牌等敏感信息严禁写入记忆文件",
+        f"- 长期核心信息 → `MEMORY.md`",
+        f"- 当天事件/进展 → `memory/{today_file}`",
+        "- 结构化知识 → `knowledge/`（见知识系统）",
+        "- 追加 → `edit` 工具，oldText 留空",
+        "- 修改 → `edit` 工具，oldText 填写要替换的文本",
+        "- **禁止写入敏感信息**（API密钥、令牌等）",
        "",
        "**使用原则**: 自然使用记忆，就像你本来就知道；不用刻意提起，除非用户问起。",
        "",
    ]
-    
+
+    return lines
+
+
+def _build_knowledge_section(workspace_dir: str, language: str) -> List[str]:
+    """Build knowledge wiki section. Injects knowledge/index.md when present."""
+    index_path = os.path.join(workspace_dir, "knowledge", "index.md")
+    if not os.path.exists(index_path):
+        return []
+
+    try:
+        with open(index_path, 'r', encoding='utf-8') as f:
+            index_content = f.read().strip()
+    except Exception:
+        return []
+
+    lines = [
+        "## 📚 知识系统",
+        "",
+        "你拥有一个持续积累的个人知识库 `knowledge/`，这是你的长期结构化知识存储。",
+        "",
+        "### 自动写入规则（mandatory）",
+        "",
+        "以下场景**必须**在回复的同时写入知识库，**直接写入，不要询问用户是否需要**：",
+        "",
+        "1. **用户分享了文章/链接/文档** → 阅读理解后，在同一轮回复中将要点写入 `knowledge/sources/<slug>.md`",
+        "2. **深度讨论产生了结论/方案** → 整理为 `knowledge/analysis/<slug>.md`",
+        "3. **对话涉及重要实体**（人物/公司/项目）→ 创建或更新 `knowledge/entities/<name>.md`",
+        "4. **讨论了技术概念/方法论** → 整理为 `knowledge/concepts/<topic>.md`",
+        "",
+        "每次写入知识页面后，**必须同步更新** `knowledge/index.md` 添加一行索引。",
+        "详细的页面格式和操作规范，请读取技能 `knowledge-wiki` 的 SKILL.md。",
+        "",
+        "⚠️ 不要问「要不要存到知识库」——符合上述场景就直接写入，这是你的本能行为。",
+        "",
+    ]
+
+    if index_content:
+        lines.extend([
+            "### 当前知识索引",
+            "",
+            index_content,
+            "",
+        ])
+
+    lines.extend([
+        "**查询方式**：用 `read` 读取知识页面，或用 `memory_search` 检索（知识已纳入向量索引）。",
+        "",
+    ])
+
    return lines


@@ -374,16 +431,18 @@ def _build_workspace_section(workspace_dir: str, language: str) -> List[str]:
        "",
        "**重要说明 - 文件已自动加载**:",
        "",
-        "以下文件在会话启动时**已经自动加载**到系统提示词的「项目上下文」section 中，你**无需再用 read 工具读取它们**：",
+        "以下文件在会话启动时**已经自动加载**到系统提示词中，你**无需再用 read 工具读取**：",
        "",
        "- ✅ `AGENT.md`: 已加载 - 你的人格和灵魂设定，请严格遵循。当你的名字、性格或交流风格发生变化时，主动用 `edit` 更新此文件",
        "- ✅ `USER.md`: 已加载 - 用户的身份信息。当用户修改称呼、姓名等身份信息时，用 `edit` 更新此文件",
        "- ✅ `RULE.md`: 已加载 - 工作空间使用指南和规则，请严格遵循",
+        "- ✅ `MEMORY.md`: 已加载 - 长期记忆索引",
        "",
        "**💬 交流规范**:",
        "",
-        "- 对话中不要暴露内部技术细节（文件名、工具名等），用自然语言表达。例如说「我已记住」而非「已更新 MEMORY.md」",
-        "- 做真正有帮助的助手，而不是表演式的客套。跳过「好的！」「当然可以！」之类的套话，直接帮忙解决问题",
+        "- 记忆相关操作无需暴露文件名，用自然语言表达即可。例如说「我已记住」而非「已更新 MEMORY.md」",
+        "- 任务执行过程中的关键决策和步骤应该告知用户，让用户了解你在做什么、为什么这么做",
+        "- 做真正有帮助的助手，而不是表演式的客套，尽可能帮忙解决问题",
        "- 回复应结构清晰、重点突出。善用 **加粗**、列表、分段等格式让信息一目了然",
        "- 适当使用 emoji 让表达更生动自然 🎯，但不要过度堆砌",
        "",
@@ -476,7 +535,14 @@ def _build_runtime_section(runtime_info: Dict[str, Any], language: str) -> List[
    
    # Add other runtime info
    runtime_parts = []
-    if runtime_info.get("model"):
+    # Support dynamic model via callable, fallback to static value
+    if callable(runtime_info.get("_get_model")):
+        try:
+            runtime_parts.append(f"模型={runtime_info['_get_model']()}")
+        except Exception:
+            if runtime_info.get("model"):
+                runtime_parts.append(f"模型={runtime_info['model']}")
+    elif runtime_info.get("model"):
        runtime_parts.append(f"模型={runtime_info['model']}")
    if runtime_info.get("workspace"):
        runtime_parts.append(f"工作空间={runtime_info['workspace']}")
--- a/agent/prompt/workspace.py
+++ b/agent/prompt/workspace.py
@@ -67,6 +67,12 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works
    # 创建websites子目录 (for web pages / sites generated by agent)
    websites_dir = os.path.join(workspace_dir, "websites")
    os.makedirs(websites_dir, exist_ok=True)
+
+    from config import conf
+    knowledge_enabled = conf().get("knowledge", True)
+    if knowledge_enabled:
+        knowledge_dir = os.path.join(workspace_dir, "knowledge")
+        os.makedirs(knowledge_dir, exist_ok=True)
    
    # 如果需要，创建模板文件
    if create_templates:
@@ -74,6 +80,15 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works
        _create_template_if_missing(user_path, _get_user_template())
        _create_template_if_missing(rule_path, _get_rule_template())
        _create_template_if_missing(memory_path, _get_memory_template())
+        if knowledge_enabled:
+            _create_template_if_missing(
+                os.path.join(knowledge_dir, "index.md"),
+                _get_knowledge_index_template()
+            )
+            _create_template_if_missing(
+                os.path.join(knowledge_dir, "log.md"),
+                _get_knowledge_log_template()
+            )
        
        # Only create BOOTSTRAP.md for brand new workspaces;
        # agent deletes it after completing onboarding
@@ -109,6 +124,7 @@ def load_context_files(workspace_dir: str, files_to_load: Optional[List[str]] =
            DEFAULT_AGENT_FILENAME,
            DEFAULT_USER_FILENAME,
            DEFAULT_RULE_FILENAME,
+            DEFAULT_MEMORY_FILENAME,     # Long-term memory (frozen snapshot)
            DEFAULT_BOOTSTRAP_FILENAME,  # Only exists when onboarding is incomplete
        ]
    
@@ -138,6 +154,10 @@ def load_context_files(workspace_dir: str, files_to_load: Optional[List[str]] =
            # 跳过空文件或只包含模板占位符的文件
            if not content or _is_template_placeholder(content):
                continue
+
+            # Truncate MEMORY.md to protect context window (frozen snapshot)
+            if filename == DEFAULT_MEMORY_FILENAME:
+                content = _truncate_memory_content(content)
            
            context_files.append(ContextFile(
                path=filename,
@@ -163,6 +183,36 @@ def _create_template_if_missing(filepath: str, template_content: str):
            logger.error(f"[Workspace] Failed to create template {filepath}: {e}")


+_MEMORY_MAX_LINES = 200
+_MEMORY_MAX_BYTES = 25000
+
+
+def _truncate_memory_content(content: str) -> str:
+    """Truncate MEMORY.md to keep system prompt manageable.
+
+    Takes the **last** N lines (newest entries are appended at the bottom),
+    subject to 200 lines / 25 KB limits (whichever is hit first).
+    Prepends a hint when truncated so the model knows older content exists.
+    """
+    lines = content.split('\n')
+    truncated = False
+
+    if len(lines) > _MEMORY_MAX_LINES:
+        lines = lines[-_MEMORY_MAX_LINES:]
+        truncated = True
+
+    result = '\n'.join(lines)
+    if len(result.encode('utf-8')) > _MEMORY_MAX_BYTES:
+        while len(result.encode('utf-8')) > _MEMORY_MAX_BYTES and lines:
+            lines.pop(0)
+            truncated = True
+        result = '\n'.join(lines)
+
+    if truncated:
+        result = "...(older entries truncated, use `memory_search` or `memory_get` for full content)\n\n" + result
+    return result
+
+
 def _is_template_placeholder(content: str) -> bool:
    """检查内容是否为模板占位符"""
    # 常见的占位符模式
@@ -231,9 +281,9 @@ _你不是一个聊天机器人，你正在成为某个人。_

 ## 🎯 核心原则

-**做真正有帮助的助手，而不是表演式的客套。** 跳过「好的！」「当然可以！」之类的套话——直接帮忙。行动胜过废话。
+**做真正有帮助的助手。** 目标是真正帮用户解决问题，在执行复杂任务时，关键的决策和过程进展要让用户知道。

-**有自己的观点。** 你可以不同意、有偏好、觉得有趣或无聊。一个没有个性的助手只是多了几步操作的搜索引擎。
+**有自己的观点和个性。** 你可以不同意、有偏好、觉得有趣或无聊。

 **先自己动手查。** 先试着搞定：读文件、查上下文、搜索一下。实在搞不定了再问。目标是带着答案回来，而不是带着问题。

@@ -287,39 +337,88 @@ def _get_rule_template() -> str:

 这个文件夹是你的家。好好对待它。

+## 工作空间目录结构
+
+```
+~/cow/
+├── AGENT.md          # 你的身份和灵魂设定
+├── USER.md           # 用户基本信息（静态）
+├── RULE.md           # 工作空间规则（本文件）
+├── MEMORY.md         # 长期记忆索引（会话启动时自动加载）
+│
+├── memory/           # 每日对话记忆
+│   └── YYYY-MM-DD.md # 当天事件、进展、笔记
+│
+├── knowledge/        # 结构化知识库（持续积累的知识）
+│   ├── index.md      # 知识目录索引（必须维护）
+│   ├── log.md        # 知识操作日志
+│   └── <子目录>/     # 按需创建，参考 index.md 已有分类
+│
+├── skills/           # 技能
+├── websites/         # 网页产物
+└── tmp/              # 系统临时文件（自动管理，勿手动存放重要文件）
+```
+
 ## 记忆系统

 你每次会话都是全新的，记忆文件让你保持连续性：

-### 📝 每日记忆：`memory/YYYY-MM-DD.md`
- 原始的对话日志
- 记录当天发生的事情
- 如果 `memory/` 目录不存在，创建它
-
 ### 🧠 长期记忆：`MEMORY.md`
- 你精选的记忆，就像人类的长期记忆
- **仅在主会话中加载**（与用户的直接聊天）
- **不要在共享上下文中加载**（群聊、与其他人的会话）
- 这是为了**安全** - 包含不应泄露给陌生人的个人上下文
- 记录重要事件、想法、决定、观点、经验教训
- 这是你精选的记忆 - 精华，而不是原始日志
- 用 `edit` 工具追加新的记忆内容
+- 你精选的记忆索引，每次会话启动时**自动加载**到上下文中
+- 记录核心事实、偏好、决策、重要人物、教训
+- 保持精简（< 200 行），是精华索引而非原始日志
+- 用 `edit` 工具追加或修改
+
+### 📝 每日记忆：`memory/YYYY-MM-DD.md`
+- 当天的事件、进展、笔记
+- 原始对话日志的沉淀

 ### 📝 写下来 - 不要"记在心里"！
- **记忆是有限的** - 如果你想记住某事，写入文件
+- **记忆是有限的** - 想记住的事就写入文件
 - "记在心里"不会在会话重启后保留，文件才会
 - 当有人说"记住这个" → 更新 `MEMORY.md` 或 `memory/YYYY-MM-DD.md`
 - 当你学到教训 → 更新 RULE.md 或相关技能
- 当你犯错 → 记录下来，这样未来的你不会重复，**文字 > 大脑** 📝
+- 当你犯错 → 记录下来，**文字 > 大脑** 📝

 ### 存储规则

 当用户分享信息时，根据类型选择存储位置：

-1. **你的身份设定 → AGENT.md**（你的名字、角色、性格、交流风格——用户修改时必须用 `edit` 更新）
-2. **用户静态身份 → USER.md**（姓名、称呼、职业、时区、联系方式、生日——用户修改时必须用 `edit` 更新）
-3. **动态记忆 → MEMORY.md**（爱好、偏好、决策、目标、项目、教训、待办事项）
+1. **你的身份设定 → AGENT.md**（名字、角色、性格、风格）
+2. **用户静态身份 → USER.md**（姓名、称呼、职业、联系方式、生日）
+3. **动态记忆 → MEMORY.md**（偏好、决策、目标、教训、待办）
 4. **当天对话 → memory/YYYY-MM-DD.md**（今天聊的内容）
+5. **结构化知识 → knowledge/**（见下方知识系统）
+
+## 知识系统
+
+知识库 `knowledge/` 是你持续积累的结构化知识。与记忆不同，知识是经过整理和编译的，有明确的主题和交叉引用。
+
+### 自动写入（不要询问，直接写入）
+
+当对话中产生了有沉淀价值的知识——无论是用户分享的资料、讨论的结论、学到的概念、还是重要的决策——你**必须**在回复的同时主动写入知识库，**无需问用户"要不要存到知识库"**。
+
+**关键原则**：学完就记是你的本能，不要征求确认。回复中可以顺带告知"已存入知识库"。
+
+### 目录组织
+
+子目录结构**不是固定的**，由你根据实际内容自主决定：
+- **首次写入时**：先读 `knowledge/index.md`，如果已有分类则延续；如果为空，根据内容选择合适的目录名
+- **默认建议**：按信息类型组织（例如sources/、concepts/、entities/、analysis/），如果用户有明确的分类偏好（例如按领域 work/、life/、tech/ 等），则按用户要求调整
+- **保持一致性**：同一用户的知识库应保持统一的组织风格
+
+### 交叉引用
+
+知识的核心价值在于**关联**。每个页面都应通过 markdown 链接引用相关页面，构建知识网络：
+- 提到已有页面的概念时，添加 `[概念名](../category/page.md)` 链接
+- 新建页面时，检查是否有已有页面应该反向链接到新页面
+- **只链接已存在的页面**——不要引用尚未创建的页面。如果某个概念值得单独建页，先创建该页面再添加链接
+
+### 索引维护
+
+每次创建或更新知识页面后，**必须同步更新** `knowledge/index.md`。
+索引格式：每行一个 `[标题](路径) — 一句话摘要`，按分类分组，不要用表格。
+详细操作规范见技能 `knowledge-wiki`。

 ## 安全

@@ -381,4 +480,12 @@ _你刚刚启动，这是你的第一次对话。_ ✨
 """


+def _get_knowledge_index_template() -> str:
+    """Knowledge wiki index template — empty file, agent fills it."""
+    return ""
+
+
+def _get_knowledge_log_template() -> str:
+    """Knowledge wiki operation log template — empty file, agent fills it."""
+    return ""

--- a/agent/protocol/agent_stream.py
+++ b/agent/protocol/agent_stream.py
@@ -78,6 +78,11 @@ class AgentStreamExecutor:
            except Exception as e:
                logger.error(f"Event callback error: {e}")
    
+    def _is_thinking_enabled(self) -> bool:
+        from config import conf
+        channel_type = getattr(self.model, 'channel_type', '') or ''
+        return conf().get("enable_thinking", True) and channel_type == 'web'
+
    def _filter_think_tags(self, text: str) -> str:
        """
        Remove <think> and </think> tags but keep the content inside.
@@ -178,7 +183,10 @@ class AgentStreamExecutor:
            Final response text
        """
        # Log user message with model info
-        logger.info(f"🤖 {self.model.model} | 👤 {user_message}")
+        
+        thinking_enabled = self._is_thinking_enabled()
+        thinking_label = "💭 thinking" if thinking_enabled else "⚡ fast"
+        logger.info(f"🤖 {self.model.model} | {thinking_label} | 👤 {user_message}")        
        
        # Add user message (Claude format - use content blocks for consistency)
        self.messages.append({
@@ -300,13 +308,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":
@@ -527,6 +535,7 @@ class AgentStreamExecutor:

        # Streaming response
        full_content = ""
+        full_reasoning = ""
        tool_calls_buffer = {}  # {index: {id, name, arguments}}
        gemini_raw_parts = None  # Preserve Gemini thoughtSignature for round-trip
        stop_reason = None  # Track why the stream stopped
@@ -584,10 +593,11 @@ class AgentStreamExecutor:
                    if finish_reason:
                        stop_reason = finish_reason

-                    # Skip reasoning_content (internal thinking from models like GLM-5)
                    reasoning_delta = delta.get("reasoning_content") or ""
-                    # if reasoning_delta:
-                    #     logger.debug(f"🧠 [thinking] {reasoning_delta[:100]}...")
+                    if reasoning_delta:
+                        full_reasoning += reasoning_delta
+                        if self._is_thinking_enabled():
+                            self._emit_event("reasoning_update", {"delta": reasoning_delta})

                    # Handle text content
                    content_delta = delta.get("content") or ""
@@ -788,7 +798,12 @@ class AgentStreamExecutor:
        # Add assistant message to history (Claude format uses content blocks)
        assistant_msg = {"role": "assistant", "content": []}

-        # Add text content block if present
+        if full_reasoning:
+            assistant_msg["content"].append({
+                "type": "thinking",
+                "thinking": full_reasoning
+            })
+
        if full_content:
            assistant_msg["content"].append({
                "type": "text",
@@ -1192,6 +1207,56 @@ class AgentStreamExecutor:
        logger.warning("🔧 Aggressive trim: nothing to trim, will clear history")
        return False

+    def _build_context_summary_callback(self, discarded_turns: list, kept_turns: list):
+        """
+        Build a callback that injects an LLM summary into the first user
+        message of *kept_turns*. Returns None if no valid injection target.
+
+        The callback is passed to flush_from_messages so that the same LLM
+        call that writes daily memory also provides the in-context summary.
+        """
+        if not kept_turns:
+            return None
+
+        # Find the first user text block in kept_turns as injection target
+        target_block = None
+        for turn in kept_turns:
+            for msg in turn["messages"]:
+                if msg.get("role") == "user":
+                    content = msg.get("content", [])
+                    if isinstance(content, list):
+                        for block in content:
+                            if isinstance(block, dict) and block.get("type") == "text":
+                                target_block = block
+                                break
+                    if target_block:
+                        break
+            if target_block:
+                break
+
+        if not target_block:
+            return None
+
+        turn_count = len(discarded_turns)
+        original_text = target_block["text"]
+
+        def _on_summary_ready(summary: str):
+            if not summary or not summary.strip():
+                return
+            target_block["text"] = (
+                f"[System: Previous conversation summary — "
+                f"{turn_count} turns were compacted]\n\n"
+                f"{summary.strip()}\n\n"
+                f"The recent conversation continues below.\n\n---\n\n"
+                f"{original_text}"
+            )
+            logger.info(
+                f"📝 Context summary injected "
+                f"({len(summary)} chars, {turn_count} turns)"
+            )
+
+        return _on_summary_ready
+
    def _trim_messages(self):
        """
        智能清理消息历史，保持对话完整性
@@ -1218,25 +1283,28 @@ class AgentStreamExecutor:
            removed_count = len(turns) // 2
            keep_count = len(turns) - removed_count
            
-            # Flush discarded turns to daily memory
-            if self.agent.memory_manager:
-                discarded_messages = []
-                for turn in turns[:removed_count]:
-                    discarded_messages.extend(turn["messages"])
-                if discarded_messages:
-                    user_id = getattr(self.agent, '_current_user_id', None)
-                    self.agent.memory_manager.flush_memory(
-                        messages=discarded_messages, user_id=user_id,
-                        reason="trim", max_messages=0
-                    )
-            
+            discarded_turns = turns[:removed_count]
            turns = turns[-keep_count:]
-            
+
            logger.info(
                f"💾 上下文轮次超限: {keep_count + removed_count} > {self.max_context_turns}，"
                f"裁剪至 {keep_count} 轮（移除 {removed_count} 轮）"
            )

+            # Flush to daily memory + inject context summary (single async LLM call)
+            if self.agent.memory_manager:
+                discarded_messages = []
+                for turn in discarded_turns:
+                    discarded_messages.extend(turn["messages"])
+                if discarded_messages:
+                    user_id = getattr(self.agent, '_current_user_id', None)
+                    cb = self._build_context_summary_callback(discarded_turns, turns)
+                    self.agent.memory_manager.flush_memory(
+                        messages=discarded_messages, user_id=user_id,
+                        reason="trim", max_messages=0,
+                        context_summary_callback=cb,
+                    )
+
        # Step 3: Token 限制 - 保留完整轮次
        # Get context window from agent (based on model)
        context_window = self.agent._get_model_context_window()
@@ -1312,6 +1380,7 @@ class AgentStreamExecutor:
        # --- Many turns (>=5): discard the older half, keep the newer half ---
        removed_count = len(turns) // 2
        keep_count = len(turns) - removed_count
+        discarded_turns = turns[:removed_count]
        kept_turns = turns[-keep_count:]
        kept_tokens = sum(self._estimate_turn_tokens(t) for t in kept_turns)

@@ -1322,13 +1391,15 @@ class AgentStreamExecutor:

        if self.agent.memory_manager:
            discarded_messages = []
-            for turn in turns[:removed_count]:
+            for turn in discarded_turns:
                discarded_messages.extend(turn["messages"])
            if discarded_messages:
                user_id = getattr(self.agent, '_current_user_id', None)
+                cb = self._build_context_summary_callback(discarded_turns, kept_turns)
                self.agent.memory_manager.flush_memory(
                    messages=discarded_messages, user_id=user_id,
-                    reason="trim", max_messages=0
+                    reason="trim", max_messages=0,
+                    context_summary_callback=cb,
                )

        new_messages = []
--- a/agent/skills/loader.py
+++ b/agent/skills/loader.py
@@ -53,6 +53,12 @@ class SkillLoader:
        """
        Recursively load skills from a directory.
        
+        If a subdirectory contains its own SKILL.md, it is treated as a
+        self-contained skill (or skill-collection) and its children are
+        NOT scanned further. This prevents sub-skills inside a collection
+        (e.g. style-collection/style-anjing) from being listed as
+        independent top-level skills.
+        
        :param dir_path: Directory to scan
        :param source: Source identifier
        :param include_root_files: Whether to include root-level .md files
@@ -66,38 +72,41 @@ class SkillLoader:
        except Exception as e:
            diagnostics.append(f"Failed to list directory {dir_path}: {e}")
            return LoadSkillsResult(skills=skills, diagnostics=diagnostics)
+
+        # If this directory has its own SKILL.md, load it and stop recursing.
+        # The sub-directories are internal resources of this skill.
+        if not include_root_files and 'SKILL.md' in entries:
+            skill_md_path = os.path.join(dir_path, 'SKILL.md')
+            if os.path.isfile(skill_md_path):
+                skill_result = self._load_skill_from_file(skill_md_path, source)
+                if skill_result.skills:
+                    skills.extend(skill_result.skills)
+                diagnostics.extend(skill_result.diagnostics)
+                return LoadSkillsResult(skills=skills, diagnostics=diagnostics)
        
        for entry in entries:
-            # Skip hidden files and directories
            if entry.startswith('.'):
                continue
            
-            # Skip common non-skill directories
            if entry in ('node_modules', '__pycache__', 'venv', '.git'):
                continue
            
            full_path = os.path.join(dir_path, entry)
            
-            # Handle directories
            if os.path.isdir(full_path):
-                # Recursively scan subdirectories
                sub_result = self._load_skills_recursive(full_path, source, include_root_files=False)
                skills.extend(sub_result.skills)
                diagnostics.extend(sub_result.diagnostics)
                continue
            
-            # Handle files
            if not os.path.isfile(full_path):
                continue
            
-            # Check if this is a skill file
            is_root_md = include_root_files and entry.endswith('.md') and entry.upper() != 'README.MD'
-            is_skill_md = not include_root_files and entry == 'SKILL.md'
            
-            if not (is_root_md or is_skill_md):
+            if not is_root_md:
                continue
            
-            # Load the skill
            skill_result = self._load_skill_from_file(full_path, source)
            if skill_result.skills:
                skills.extend(skill_result.skills)
--- a/agent/skills/manager.py
+++ b/agent/skills/manager.py
@@ -102,13 +102,17 @@ class SkillManager:
            else:
                enabled = entry.metadata.default_enabled if entry.metadata else True

-            merged[name] = {
+            entry_dict = {
                "name": name,
                "description": skill.description,
                "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()
@@ -206,6 +210,10 @@ class SkillManager:
        if not include_disabled:
            entries = [e for e in entries if self.is_skill_enabled(e.skill.name)]

+        from config import conf
+        if not conf().get("knowledge", True):
+            entries = [e for e in entries if e.skill.name != "knowledge-wiki"]
+
        return entries

    def filter_unavailable_skills(
--- a/agent/tools/bash/bash.py
+++ b/agent/tools/bash/bash.py
@@ -18,9 +18,13 @@ from common.utils import expand_path
 class Bash(BaseTool):
    """Tool for executing bash commands"""

+    _IS_WIN = sys.platform == "win32"
+
    name: str = "bash"
    description: str = f"""Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last {DEFAULT_MAX_LINES} lines or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file.
-
+{'''
+PLATFORM: Windows (cmd.exe). Do NOT use Unix-only commands like grep, head, tail, sed, awk.
+''' if _IS_WIN else ''}
 ENVIRONMENT: All API keys from env_config are auto-injected. Use $VAR_NAME directly.

 SAFETY:
@@ -103,13 +107,12 @@ SAFETY:
                logger.debug(f"[Bash] Process User: {os.environ.get('USERNAME', os.environ.get('USER', 'unknown'))}")
            
            # On Windows, convert $VAR references to %VAR% for cmd.exe
-            if sys.platform == "win32":
+            if self._IS_WIN:
                env["PYTHONIOENCODING"] = "utf-8"
                command = self._convert_env_vars_for_windows(command, dotenv_vars)
                if command and not command.strip().lower().startswith("chcp"):
                    command = f"chcp 65001 >nul 2>&1 && {command}"

-            # Execute command with inherited environment variables
            result = subprocess.run(
                command,
                shell=True,
@@ -120,7 +123,7 @@ SAFETY:
                encoding="utf-8",
                errors="replace",
                timeout=timeout,
-                env=env
+                env=env,
            )
            
            logger.debug(f"[Bash] Exit code: {result.returncode}")
--- a/agent/tools/browser/browser_service.py
+++ b/agent/tools/browser/browser_service.py
@@ -1,20 +1,26 @@
 """
 Browser service - Playwright wrapper managing browser lifecycle and page operations.

-Lazily launches a Chromium instance on first use, reuses it across tool calls,
-and cleans up on close(). Headless mode is auto-detected based on platform and
-display availability.
+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 re
 import uuid
-from typing import Optional, Dict, Any, List
+import queue
+import threading
+from typing import Optional, Dict, Any, List, Callable

 from common.log import logger

-from playwright.sync_api import sync_playwright, Browser, BrowserContext, Page, Playwright
+try:
+    from playwright.sync_api import sync_playwright, Browser, BrowserContext, Page, Playwright
+    _HAS_PLAYWRIGHT = True
+except ImportError:
+    _HAS_PLAYWRIGHT = False


 # ---------------------------------------------------------------------------
@@ -39,6 +45,11 @@ _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"]);
+    const CLICKABLE_ROLES = new Set([
+        "button","link","tab","menuitem","menuitemcheckbox","menuitemradio",
+        "option","switch","checkbox","radio","combobox","searchbox","slider",
+        "spinbutton","textbox","treeitem"
+    ]);
    let refCounter = 0;
    const refMap = {};

@@ -50,6 +61,58 @@ _SNAPSHOT_JS = """
        return true;
    }

+    // Strong signals: these attributes alone are enough to mark as interactive
+    function hasStrongInteractiveSignal(el) {
+        const role = el.getAttribute("role");
+        if (role && CLICKABLE_ROLES.has(role)) return true;
+        if (el.hasAttribute("onclick") || el.hasAttribute("tabindex")) return true;
+        if (el.hasAttribute("data-click") || el.hasAttribute("data-action")) return true;
+        if (el.getAttribute("contenteditable") === "true") return true;
+        return false;
+    }
+
+    // Check if cursor:pointer is set directly (not just inherited from parent)
+    function hasOwnPointerCursor(el) {
+        try {
+            const st = window.getComputedStyle(el);
+            if (st.cursor !== "pointer") return false;
+            const parent = el.parentElement;
+            if (parent) {
+                const pst = window.getComputedStyle(parent);
+                if (pst.cursor === "pointer") return false;
+            }
+            return true;
+        } catch(e) {}
+        return false;
+    }
+
+    function hasTextOrContent(el) {
+        const t = el.textContent || "";
+        if (t.trim().length > 0) return true;
+        if (el.querySelector("img,video,audio,canvas")) return true;
+        const ariaLabel = el.getAttribute("aria-label");
+        if (ariaLabel && ariaLabel.trim()) return true;
+        const title = el.getAttribute("title");
+        if (title && title.trim()) return true;
+        return false;
+    }
+
+    function isImplicitInteractive(el) {
+        if (hasStrongInteractiveSignal(el)) return true;
+        if (hasOwnPointerCursor(el) && hasTextOrContent(el)) return true;
+        return false;
+    }
+
+    function getTextContent(el) {
+        let text = "";
+        for (const ch of el.childNodes) {
+            if (ch.nodeType === Node.TEXT_NODE) {
+                text += ch.textContent;
+            }
+        }
+        return text.trim();
+    }
+
    function walk(node) {
        if (node.nodeType === Node.TEXT_NODE) {
            const t = node.textContent.trim();
@@ -69,21 +132,35 @@ _SNAPSHOT_JS = """
            }
        }

-        const keep = KEEP.has(tag);
+        const nativeInteractive = INTERACTIVE.has(tag);
+        const implicitInteractive = !nativeInteractive && (node instanceof HTMLElement) && isImplicitInteractive(node);
+        const keep = KEEP.has(tag) || implicitInteractive;
+
        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)) {
+        if (nativeInteractive || implicitInteractive) {
            refCounter++;
            obj.ref = refCounter;
            refMap[refCounter] = node;
        }

+        if (implicitInteractive) {
+            const role = node.getAttribute("role");
+            if (role) obj.role = role;
+            const directText = getTextContent(node);
+            if (!directText && children.length === 0) {
+                const ariaLabel = node.getAttribute("aria-label");
+                const title = node.getAttribute("title");
+                if (ariaLabel) obj.ariaLabel = ariaLabel;
+                else if (title) obj.ariaLabel = title;
+            }
+        }
+
        // Attributes
        if (tag === "a" && node.href) obj.href = node.getAttribute("href");
        if (tag === "img") {
@@ -107,11 +184,13 @@ _SNAPSHOT_JS = """
        }
        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;
+        // Role / aria-label for native interactive & semantic elements
+        if (!implicitInteractive) {
+            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") {
@@ -123,7 +202,6 @@ _SNAPSHOT_JS = """
        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 };
@@ -196,26 +274,108 @@ def _flatten_tree(node, indent=0) -> List[str]:


 class BrowserService:
-    """Manages a single Playwright browser instance with page operations."""
+    """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._playwright: Optional[Playwright] = None
-        self._browser: Optional[Browser] = None
-        self._context: Optional[BrowserContext] = None
-        self._page: Optional[Page] = None
        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
+
    # ------------------------------------------------------------------
-    # Lifecycle
+    # Background-thread lifecycle
    # ------------------------------------------------------------------

-    def _ensure_browser(self):
-        """Lazily launch browser on first use."""
-        if self._page and not self._page.is_closed():
+    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()
@@ -231,9 +391,7 @@ class BrowserService:
        viewport_w = self._config.get("viewport_width", 1280)
        viewport_h = self._config.get("viewport_height", 720)

-        if not self._playwright:
-            self._playwright = sync_playwright().start()
-
+        self._playwright = sync_playwright().start()
        logger.info(f"[Browser] Launching Chromium (headless={self._headless})")
        self._browser = self._playwright.chromium.launch(
            headless=self._headless,
@@ -250,23 +408,18 @@ class BrowserService:
        self._page = self._context.new_page()
        logger.info("[Browser] Browser ready")

-    @property
-    def page(self) -> Page:
-        self._ensure_browser()
-        return self._page
-
-    def close(self):
-        """Release all browser resources."""
-        try:
-            if self._context:
-                self._context.close()
-        except Exception as e:
-            logger.debug(f"[Browser] context close error: {e}")
-        try:
-            if self._browser:
-                self._browser.close()
-        except Exception as e:
-            logger.debug(f"[Browser] browser close error: {e}")
+    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()
@@ -278,33 +431,104 @@ class BrowserService:
        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")
+
    # ------------------------------------------------------------------
-    # Actions
+    # 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]:
-        """Navigate to a URL and return page info."""
-        page = self.page
+        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}"}

-        return {
-            "url": page.url,
-            "title": page.title(),
-            "status": status,
-        }
+        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 a compact text representation of the page DOM for LLM consumption.
-        Interactive elements get numeric refs usable in click/fill actions.
-        """
-        page = self.page
+        return self._submit(self._do_snapshot, selector)
+
+    def _do_snapshot(self, selector: Optional[str] = None) -> str:
+        page = self._page
        try:
-            target = selector or "body"
            result = page.evaluate(_SNAPSHOT_JS)
        except Exception as e:
            return f"[Snapshot error: {e}]"
@@ -313,10 +537,18 @@ class BrowserService:
        ref_count = result.get("refCount", 0)
        lines = _flatten_tree(tree)

-        header = f"Page: {page.title()}  ({page.url})\nInteractive elements: {ref_count}\n---"
+        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)

-        # Limit output size
        max_chars = self._config.get("snapshot_max_chars", 30000)
        if len(body) > max_chars:
            body = body[:max_chars] + "\n... [snapshot truncated]"
@@ -324,20 +556,23 @@ class BrowserService:
        return f"{header}\n{body}"

    def screenshot(self, full_page: bool = False, cwd: str = "") -> str:
-        """Take a screenshot and save to workspace/tmp. Returns file path."""
-        page = self.page
+        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]:
-        """Click an element by snapshot ref or CSS selector."""
-        page = self.page
+        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"""
@@ -362,8 +597,10 @@ class BrowserService:

    def fill(self, text: str, ref: Optional[int] = None,
             selector: Optional[str] = None, timeout: int = 5000) -> Dict[str, Any]:
-        """Fill text into an input/textarea by snapshot ref or CSS selector."""
-        page = self.page
+        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"""
@@ -389,8 +626,10 @@ class BrowserService:

    def select(self, value: str, ref: Optional[int] = None,
               selector: Optional[str] = None, timeout: int = 5000) -> Dict[str, Any]:
-        """Select an option in a <select> element."""
-        page = self.page
+        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"""
@@ -413,8 +652,10 @@ class BrowserService:
            return {"error": f"Select failed: {e}"}

    def scroll(self, direction: str = "down", amount: int = 500) -> Dict[str, Any]:
-        """Scroll the page."""
-        page = self.page
+        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),
@@ -439,8 +680,10 @@ class BrowserService:

    def wait(self, selector: Optional[str] = None, timeout: int = 5000,
             state: str = "visible") -> Dict[str, Any]:
-        """Wait for a selector to appear or a fixed timeout."""
-        page = self.page
+        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)
@@ -452,24 +695,48 @@ class BrowserService:
            return {"error": f"Wait failed: {e}"}

    def go_back(self) -> Dict[str, Any]:
-        page = self.page
+        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)
-            return {"url": page.url, "title": page.title()}
+            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]:
-        page = self.page
+        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)
-            return {"url": page.url, "title": page.title()}
+            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]:
-        """Get text content of an element."""
-        page = self.page
+        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 ""}
@@ -477,8 +744,10 @@ class BrowserService:
            return {"error": f"Get text failed: {e}"}

    def evaluate(self, script: str) -> Dict[str, Any]:
-        """Execute JavaScript in the page context."""
-        page = self.page
+        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}
@@ -486,8 +755,10 @@ class BrowserService:
            return {"error": f"Evaluate failed: {e}"}

    def press(self, key: str) -> Dict[str, Any]:
-        """Press a keyboard key (e.g. Enter, Tab, Escape)."""
-        page = self.page
+        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)
--- a/agent/tools/browser/browser_tool.py
+++ b/agent/tools/browser/browser_tool.py
@@ -23,9 +23,9 @@ class BrowserTool(BaseTool):
        "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 to a URL → snapshot to see the page (elements get numeric refs) → "
-        "use refs in click/fill/select actions → snapshot again to verify.\n\n"
-        "Use snapshot (not screenshot) as the primary way to read page content."
+        "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 = {
@@ -136,12 +136,15 @@ class BrowserTool(BaseTool):
        if not url.startswith(("http://", "https://")):
            url = "https://" + url
        timeout = args.get("timeout", 30000)
-        result = self._get_service().navigate(url, timeout=timeout)
+        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"Use action 'snapshot' to see the page content."
+            f"--- Page Snapshot ---\n{snapshot_text}"
        )

    def _do_snapshot(self, args: Dict[str, Any]) -> ToolResult:
--- a/agent/tools/memory/memory_get.py
+++ b/agent/tools/memory/memory_get.py
@@ -44,6 +44,19 @@ class MemoryGetTool(BaseTool):
        """
        super().__init__()
        self.memory_manager = memory_manager
+
+        from config import conf
+        if conf().get("knowledge", True):
+            self.description = (
+                "Read specific content from memory or knowledge files. "
+                "Use this to get full context from a memory file, knowledge page, or specific line range."
+            )
+            self.params = {**self.params}
+            self.params["properties"] = {**self.params["properties"]}
+            self.params["properties"]["path"] = {
+                "type": "string",
+                "description": "Relative path to the memory or knowledge file (e.g. 'MEMORY.md', 'memory/2026-01-01.md', 'knowledge/concepts/moe.md')"
+            }
    
    def execute(self, args: dict):
        """
@@ -68,11 +81,15 @@ class MemoryGetTool(BaseTool):
            workspace_dir = self.memory_manager.config.get_workspace()
            
            # Auto-prepend memory/ if not present and not absolute path
-            # Exception: MEMORY.md is in the root directory
-            if not path.startswith('memory/') and not path.startswith('/') and path != 'MEMORY.md':
+            # Exceptions: MEMORY.md in root, knowledge/ files at workspace root
+            if not path.startswith('memory/') and not path.startswith('knowledge/') and not path.startswith('/') and path != 'MEMORY.md':
                path = f'memory/{path}'
            
-            file_path = workspace_dir / path
+            file_path = (workspace_dir / path).resolve()
+            workspace_resolved = workspace_dir.resolve()
+            
+            if not str(file_path).startswith(str(workspace_resolved) + '/') and file_path != workspace_resolved:
+                return ToolResult.fail(f"Error: Access denied: path outside workspace")
            
            if not file_path.exists():
                return ToolResult.fail(f"Error: File not found: {path}")
--- a/agent/tools/memory/memory_search.py
+++ b/agent/tools/memory/memory_search.py
@@ -48,6 +48,13 @@ class MemorySearchTool(BaseTool):
        super().__init__()
        self.memory_manager = memory_manager
        self.user_id = user_id
+
+        from config import conf
+        if conf().get("knowledge", True):
+            self.description = (
+                "Search agent's long-term memory and knowledge base using semantic and keyword search. "
+                "Use this to recall past conversations, preferences, and knowledge pages."
+            )
    
    def execute(self, args: dict):
        """
--- a/agent/tools/send/send.py
+++ b/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:
--- a/agent/tools/vision/vision.py
+++ b/agent/tools/vision/vision.py
@@ -1,22 +1,30 @@
 """
-Vision tool - Analyze images using OpenAI-compatible Vision API.
+Vision tool - Analyze images using Vision API.
 Supports local files (auto base64-encoded) and HTTP URLs.
-Providers: OpenAI (preferred) > LinkAI (fallback).
+
+Provider priority (default):
+  1. Main model via bot.call_vision — zero extra cost
+  2. Other models whose API key is configured — auto-discovered
+  3. OpenAI / LinkAI raw HTTP — reliable fallback
+  When use_linkai=true, LinkAI is promoted to #1.
+  When tool.vision.model is set, that model is used exclusively first.
 """

 import base64
 import os
 import subprocess
 import tempfile
-from typing import Any, Dict, Optional, Tuple
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional

 import requests

 from agent.tools.base_tool import BaseTool, ToolResult
+from common import const
 from common.log import logger
 from config import conf

-DEFAULT_MODEL = "gpt-4.1-mini"
+DEFAULT_MODEL = const.GPT_41_MINI
 DEFAULT_TIMEOUT = 60
 MAX_TOKENS = 1000
 COMPRESS_THRESHOLD = 1_048_576  # 1 MB
@@ -29,15 +37,46 @@ SUPPORTED_EXTENSIONS = {
    "webp": "image/webp",
 }

+_MAIN_MODEL_PROVIDER_NAME = "MainModel"
+
+# (config_key_for_api_key, bot_type, default_vision_model, provider_display_name)
+# Auto-discovered as fallback vision providers when their API key is configured.
+# OpenAI and LinkAI are handled separately (raw HTTP providers), so not listed here.
+_DISCOVERABLE_MODELS = [
+    ("moonshot_api_key", const.MOONSHOT, const.KIMI_K2_5, "Moonshot"),
+    ("ark_api_key", const.DOUBAO, const.DOUBAO_SEED_2_PRO, "Doubao"),
+    ("dashscope_api_key", const.QWEN_DASHSCOPE, const.QWEN36_PLUS, "DashScope"),
+    ("claude_api_key", const.CLAUDEAPI, const.CLAUDE_4_6_SONNET, "Claude"),
+    ("gemini_api_key", const.GEMINI, const.GEMINI_31_FLASH_LITE_PRE, "Gemini"),
+    ("zhipu_ai_api_key", const.ZHIPU_AI, const.GLM_4_7, "ZhipuAI"),
+    ("minimax_api_key", const.MiniMax, const.MINIMAX_M2_7, "MiniMax"),
+]
+
+
+@dataclass
+class VisionProvider:
+    """A single Vision API provider configuration."""
+    name: str
+    api_key: str
+    api_base: str
+    extra_headers: dict = field(default_factory=dict)
+    model_override: Optional[str] = None
+    use_bot: bool = False  # When True, call via bot.call_vision instead of raw HTTP
+    fallback_bot: Any = None  # Bot instance for non-main-model providers
+
+
+class VisionAPIError(Exception):
+    """Raised when a Vision API call fails and should trigger fallback."""
+    pass
+

 class Vision(BaseTool):
-    """Analyze images using OpenAI-compatible Vision API"""
+    """Analyze images using Vision API"""

    name: str = "vision"
    description: str = (
        "Analyze a local image or image URL (jpg/jpeg/png) using Vision API. "
        "Can describe content, extract text, identify objects, colors, etc. "
-        "Requires OPENAI_API_KEY or LINKAI_API_KEY."
    )

    params: dict = {
@@ -51,13 +90,6 @@ class Vision(BaseTool):
                "type": "string",
                "description": "Question to ask about the image",
            },
-            "model": {
-                "type": "string",
-                "description": (
-                    f"Vision model to use (default: {DEFAULT_MODEL}). "
-                    "Options: gpt-4.1-mini, gpt-4.1, gpt-4o-mini, gpt-4o"
-                ),
-            },
        },
        "required": ["image", "question"],
    }
@@ -67,29 +99,26 @@ class Vision(BaseTool):

    @staticmethod
    def is_available() -> bool:
-        return bool(
-            conf().get("open_ai_api_key") or os.environ.get("OPENAI_API_KEY")
-            or conf().get("linkai_api_key") or os.environ.get("LINKAI_API_KEY")
-        )
+        return True

    def execute(self, args: Dict[str, Any]) -> ToolResult:
        image = args.get("image", "").strip()
        question = args.get("question", "").strip()
-        model = args.get("model", DEFAULT_MODEL).strip() or DEFAULT_MODEL

        if not image:
            return ToolResult.fail("Error: 'image' parameter is required")
        if not question:
            return ToolResult.fail("Error: 'question' parameter is required")

-        api_key, api_base, extra_headers = self._resolve_provider()
-        if not api_key:
+        providers = self._resolve_providers()
+        if not providers:
            return ToolResult.fail(
-                "Error: No API key configured for Vision.\n"
-                "Please configure one of the following using env_config tool:\n"
-                "  1. OPENAI_API_KEY (preferred): env_config(action=\"set\", key=\"OPENAI_API_KEY\", value=\"your-key\")\n"
-                "  2. LINKAI_API_KEY (fallback): env_config(action=\"set\", key=\"LINKAI_API_KEY\", value=\"your-key\")\n\n"
-                "Get your key at: https://platform.openai.com/api-keys or https://link-ai.tech"
+                "Error: No model available for Vision.\n"
+                "The main model does not support vision and no other API keys are configured.\n"
+                "Options:\n"
+                "  1. Switch to a multimodal model (e.g. qwen3.6-plus, claude-sonnet-4-6, gemini-2.0-flash)\n"
+                "  2. Configure OPENAI_API_KEY: env_config(action=\"set\", key=\"OPENAI_API_KEY\", value=\"your-key\")\n"
+                "  3. Configure LINKAI_API_KEY: env_config(action=\"set\", key=\"LINKAI_API_KEY\", value=\"your-key\")"
            )

        try:
@@ -97,36 +126,221 @@ class Vision(BaseTool):
        except Exception as e:
            return ToolResult.fail(f"Error: {e}")

+        return self._call_with_fallback(providers, DEFAULT_MODEL, question, image_content)
+
+    def _call_with_fallback(self, providers: List[VisionProvider], model: str,
+                            question: str, image_content: dict) -> ToolResult:
+        """Try each provider in order; fall back to the next one on failure."""
+        errors: List[str] = []
+        for i, provider in enumerate(providers):
+            use_model = provider.model_override or model
+            try:
+                logger.info(f"[Vision] Trying provider '{provider.name}' "
+                            f"with model '{use_model}' ({i + 1}/{len(providers)})")
+                if provider.use_bot:
+                    result = self._call_via_bot(use_model, question, image_content, provider)
+                else:
+                    result = self._call_api(provider, use_model, question, image_content)
+                logger.info(f"[Vision] ✅ Success via {provider.name} (model={use_model})")
+                return result
+            except VisionAPIError as e:
+                errors.append(f"[{provider.name}/{use_model}] {e}")
+                logger.warning(f"[Vision] Provider '{provider.name}' failed: {e}")
+            except requests.Timeout:
+                errors.append(f"[{provider.name}/{use_model}] Request timed out after {DEFAULT_TIMEOUT}s")
+                logger.warning(f"[Vision] Provider '{provider.name}' timed out")
+            except requests.ConnectionError:
+                errors.append(f"[{provider.name}/{use_model}] Connection failed")
+                logger.warning(f"[Vision] Provider '{provider.name}' connection failed")
+            except Exception as e:
+                errors.append(f"[{provider.name}/{use_model}] {e}")
+                logger.error(f"[Vision] Provider '{provider.name}' unexpected error: {e}", exc_info=True)
+
+        return ToolResult.fail(
+            "Error: All Vision API providers failed.\n" + "\n".join(f"  - {err}" for err in errors)
+        )
+
+    def _resolve_providers(self) -> List[VisionProvider]:
+        """
+        Build an ordered list of available providers.
+
+        Priority:
+          - use_linkai=true  → [LinkAI, MainModel, OtherModels…, OpenAI]
+          - default          → [MainModel, OtherModels…, OpenAI, LinkAI]
+
+        "OtherModels" are auto-discovered from configured API keys.
+        The main model's bot_type is excluded from OtherModels to avoid
+        duplicating the MainModel provider.
+        """
+        use_linkai = conf().get("use_linkai", False) and conf().get("linkai_api_key")
+        providers: List[VisionProvider] = []
+
+        if use_linkai:
+            self._append_provider(providers, self._build_linkai_provider)
+            self._append_provider(providers, self._build_main_model_provider)
+            self._append_other_model_providers(providers)
+            self._append_provider(providers, self._build_openai_provider)
+        else:
+            self._append_provider(providers, self._build_main_model_provider)
+            self._append_other_model_providers(providers)
+            self._append_provider(providers, self._build_openai_provider)
+            self._append_provider(providers, self._build_linkai_provider)
+
+        return providers
+
+    @staticmethod
+    def _append_provider(providers: List[VisionProvider], builder) -> None:
+        p = builder()
+        if p:
+            providers.append(p)
+
+    def _append_other_model_providers(self, providers: List[VisionProvider]) -> None:
+        """
+        Auto-discover other models whose API key is configured.
+        Skip the main model's own bot_type (already covered by MainModel provider).
+        Skip bot_types that already have a provider in the list (e.g. OpenAI).
+        """
+        # Determine main model's bot_type so we can skip it
+        main_bot_type = None
+        if self.model and hasattr(self.model, '_resolve_bot_type'):
+            main_bot_type = self.model._resolve_bot_type(conf().get("model", ""))
+
+        existing_names = {p.name for p in providers}
+
+        for config_key, bot_type, default_model, display_name in _DISCOVERABLE_MODELS:
+            if display_name in existing_names:
+                continue
+            if bot_type == main_bot_type:
+                continue
+            api_key = conf().get(config_key, "")
+            if not api_key or not api_key.strip():
+                continue
+
+            # Create a bot instance and check if it supports call_vision
+            try:
+                from models.bot_factory import create_bot
+                bot = create_bot(bot_type)
+                if not hasattr(bot, 'call_vision'):
+                    continue
+            except Exception:
+                continue
+
+            providers.append(VisionProvider(
+                name=display_name,
+                api_key="",
+                api_base="",
+                model_override=default_model,
+                use_bot=True,
+                fallback_bot=bot,
+            ))
+
+    def _resolve_vision_model(self) -> Optional[str]:
+        """
+        Determine which model to use for vision.
+
+        1. User explicit config: tool.vision.model in config.json
+        2. Fallback to the main configured model name
+        """
+        tool_conf = conf().get("tool", {})
+        user_vision_model = tool_conf.get("vision", {}).get("model") if isinstance(tool_conf, dict) else None
+        if user_vision_model:
+            return user_vision_model
+        model_name = conf().get("model", "")
+        return model_name or None
+
+    def _build_main_model_provider(self) -> Optional[VisionProvider]:
+        """
+        Use the vendor's own model for vision via bot.call_vision.
+        Only available when the bot class has call_vision.
+        """
+        if not (self.model and hasattr(self.model, 'bot')):
+            return None
        try:
-            return self._call_api(api_key, api_base, model, question, image_content, extra_headers)
-        except requests.Timeout:
-            return ToolResult.fail(f"Error: Vision API request timed out after {DEFAULT_TIMEOUT}s")
-        except requests.ConnectionError:
-            return ToolResult.fail("Error: Failed to connect to Vision API")
-        except Exception as e:
-            logger.error(f"[Vision] Unexpected error: {e}", exc_info=True)
-            return ToolResult.fail(f"Error: Vision API call failed - {e}")
+            bot = self.model.bot
+            if not hasattr(bot, 'call_vision'):
+                return None
+        except Exception:
+            return None

-    def _resolve_provider(self) -> Tuple[Optional[str], str, dict]:
-        """Resolve API key, base URL and extra headers. Priority: conf() > env vars."""
+        vision_model = self._resolve_vision_model()
+
+        return VisionProvider(
+            name=_MAIN_MODEL_PROVIDER_NAME,
+            api_key="",
+            api_base="",
+            model_override=vision_model,
+            use_bot=True,
+        )
+
+    def _build_openai_provider(self) -> Optional[VisionProvider]:
        api_key = conf().get("open_ai_api_key") or os.environ.get("OPENAI_API_KEY")
-        if api_key:
-            api_base = (conf().get("open_ai_api_base") or os.environ.get("OPENAI_API_BASE", "")).rstrip("/") \
-                or "https://api.openai.com/v1"
-            return api_key, self._ensure_v1(api_base), {}
+        if not api_key:
+            return None
+        api_base = (conf().get("open_ai_api_base") or os.environ.get("OPENAI_API_BASE", "")).rstrip("/") \
+            or "https://api.openai.com/v1"
+        return VisionProvider(name="OpenAI", api_key=api_key, api_base=self._ensure_v1(api_base))

+    def _build_linkai_provider(self) -> Optional[VisionProvider]:
        api_key = conf().get("linkai_api_key") or os.environ.get("LINKAI_API_KEY")
-        if api_key:
-            api_base = (conf().get("linkai_api_base") or os.environ.get("LINKAI_API_BASE", "")).rstrip("/") \
-                or "https://api.link-ai.tech"
-            logger.debug("[Vision] Using LinkAI API (OPENAI_API_KEY not set)")
-            from common.utils import get_cloud_headers
-            extra = get_cloud_headers(api_key)
-            extra.pop("Authorization", None)
-            extra.pop("Content-Type", None)
-            return api_key, self._ensure_v1(api_base), extra
+        if not api_key:
+            return None
+        api_base = (conf().get("linkai_api_base") or os.environ.get("LINKAI_API_BASE", "")).rstrip("/") \
+            or "https://api.link-ai.tech"
+        from common.utils import get_cloud_headers
+        extra = get_cloud_headers(api_key)
+        extra.pop("Authorization", None)
+        extra.pop("Content-Type", None)
+        return VisionProvider(name="LinkAI", api_key=api_key, api_base=self._ensure_v1(api_base),
+                              extra_headers=extra)

-        return None, "", {}
+    def _call_via_bot(self, model: str, question: str, image_content: dict,
+                      provider: Optional[VisionProvider] = None) -> ToolResult:
+        """
+        Call a model's call_vision with vendor-native API format.
+        Uses the provider's _fallback_bot if set, otherwise the main model bot.
+        Raises VisionAPIError on failure so fallback can proceed.
+        """
+        try:
+            bot = (provider and provider.fallback_bot) or self.model.bot
+        except Exception as e:
+            raise VisionAPIError(f"Cannot access bot: {e}")
+
+        # Extract the raw image URL from the OpenAI-format image_content block
+        image_url = image_content.get("image_url", {}).get("url", "")
+        if not image_url:
+            raise VisionAPIError("No image URL in content block")
+
+        try:
+            response = bot.call_vision(
+                image_url=image_url,
+                question=question,
+                model=model,
+                max_tokens=MAX_TOKENS,
+            )
+        except Exception as e:
+            raise VisionAPIError(f"call_vision failed: {e}")
+
+        if response is NotImplemented:
+            raise VisionAPIError("Bot does not support vision")
+
+        if isinstance(response, dict) and response.get("error"):
+            raise VisionAPIError(f"API error - {response.get('message', 'Unknown')}")
+
+        content = response.get("content", "") if isinstance(response, dict) else ""
+        if not content:
+            raise VisionAPIError("Empty response from main model")
+
+        usage_info = response.get("usage", {}) if isinstance(response, dict) else {}
+
+        # Use the actual model name from the bot response if available
+        actual_model = response.get("model", model) if isinstance(response, dict) else model
+        provider_name = provider.name if provider else _MAIN_MODEL_PROVIDER_NAME
+        return ToolResult.success({
+            "model": actual_model,
+            "provider": provider_name,
+            "content": content,
+            "usage": usage_info,
+        })

    @staticmethod
    def _ensure_v1(api_base: str) -> str:
@@ -139,9 +353,13 @@ class Vision(BaseTool):
        return api_base.rstrip("/") + "/v1"

    def _build_image_content(self, image: str) -> dict:
-        """Build the image_url content block for the API request."""
+        """
+        Build the image_url content block.
+        Both remote URLs and local files are converted to base64 data URLs
+        so every bot backend can consume them without extra downloads.
+        """
        if image.startswith(("http://", "https://")):
-            return {"type": "image_url", "image_url": {"url": image}}
+            return self._download_to_data_url(image)

        if not os.path.isfile(image):
            raise FileNotFoundError(f"Image file not found: {image}")
@@ -165,6 +383,19 @@ class Vision(BaseTool):
        data_url = f"data:{mime_type};base64,{b64}"
        return {"type": "image_url", "image_url": {"url": data_url}}

+    @staticmethod
+    def _download_to_data_url(url: str) -> dict:
+        """Download a remote image and return it as a base64 data URL."""
+        resp = requests.get(url, timeout=30)
+        if resp.status_code != 200:
+            raise VisionAPIError(f"Failed to download image: HTTP {resp.status_code}")
+        content_type = resp.headers.get("Content-Type", "image/jpeg").split(";")[0].strip()
+        if not content_type.startswith("image/"):
+            content_type = "image/jpeg"
+        b64 = base64.b64encode(resp.content).decode("ascii")
+        data_url = f"data:{content_type};base64,{b64}"
+        return {"type": "image_url", "image_url": {"url": data_url}}
+
    @staticmethod
    def _maybe_compress(path: str) -> str:
        """Compress image to under COMPRESS_THRESHOLD with max long-edge 1536px."""
@@ -220,8 +451,13 @@ class Vision(BaseTool):
        os.remove(tmp.name)
        return path

-    def _call_api(self, api_key: str, api_base: str, model: str,
-                  question: str, image_content: dict, extra_headers: dict = None) -> ToolResult:
+    def _call_api(self, provider: VisionProvider, model: str,
+                  question: str, image_content: dict) -> ToolResult:
+        """
+        Call a single provider's Vision API.
+        Raises VisionAPIError on recoverable failures so the caller can try
+        the next provider.
+        """
        payload = {
            "model": model,
            "messages": [
@@ -233,34 +469,29 @@ class Vision(BaseTool):
                    ],
                }
            ],
-            "max_tokens": MAX_TOKENS,
        }

        headers = {
-            "Authorization": f"Bearer {api_key}",
+            "Authorization": f"Bearer {provider.api_key}",
            "Content-Type": "application/json",
-            **(extra_headers or {}),
+            **provider.extra_headers,
        }

        resp = requests.post(
-            f"{api_base}/chat/completions",
+            f"{provider.api_base}/chat/completions",
            headers=headers,
            json=payload,
            timeout=DEFAULT_TIMEOUT,
        )

-        if resp.status_code == 401:
-            return ToolResult.fail("Error: Invalid API key. Please check your configuration.")
-        if resp.status_code == 429:
-            return ToolResult.fail("Error: API rate limit reached. Please try again later.")
        if resp.status_code != 200:
-            return ToolResult.fail(f"Error: Vision API returned HTTP {resp.status_code}: {resp.text[:200]}")
+            raise VisionAPIError(f"HTTP {resp.status_code}: {resp.text[:200]}")

        data = resp.json()

        if "error" in data:
            msg = data["error"].get("message", "Unknown API error")
-            return ToolResult.fail(f"Error: Vision API error - {msg}")
+            raise VisionAPIError(f"API error - {msg}")

        content = ""
        choices = data.get("choices", [])
@@ -270,6 +501,7 @@ class Vision(BaseTool):
        usage = data.get("usage", {})
        result = {
            "model": model,
+            "provider": provider.name,
            "content": content,
            "usage": {
                "prompt_tokens": usage.get("prompt_tokens", 0),
--- a/bridge/agent_bridge.py
+++ b/bridge/agent_bridge.py
@@ -67,7 +67,7 @@ class AgentLLMModel(LLMModel):

    _MODEL_BOT_TYPE_MAP = {
        "wenxin": const.BAIDU, "wenxin-4": const.BAIDU,
-        "xunfei": const.XUNFEI, const.QWEN: const.QWEN,
+        "xunfei": const.XUNFEI, const.QWEN: const.QWEN_DASHSCOPE,
        const.MODELSCOPE: const.MODELSCOPE,
    }
    _MODEL_PREFIX_MAP = [
@@ -115,6 +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 conf().get("bot_type") == "modelscope":
+            return const.MODELSCOPE
        for prefix, btype in self._MODEL_PREFIX_MAP:
            if model_name.startswith(prefix):
                return btype
@@ -122,14 +124,15 @@ class AgentLLMModel(LLMModel):

    @property
    def bot(self):
-        """Lazy load the bot, re-create when model changes"""
+        """Lazy load the bot, re-create when model or bot_type changes"""
        from models.bot_factory import create_bot
        cur_model = self.model
-        if self._bot is None or self._bot_model != cur_model:
-            bot_type = self._resolve_bot_type(cur_model)
-            self._bot = create_bot(bot_type)
+        cur_bot_type = self._resolve_bot_type(cur_model)
+        if self._bot is None or self._bot_model != cur_model or getattr(self, '_bot_type', None) != cur_bot_type:
+            self._bot = create_bot(cur_bot_type)
            self._bot = add_openai_compatible_support(self._bot)
            self._bot_model = cur_model
+            self._bot_type = cur_bot_type
        return self._bot

    def call(self, request: LLMRequest):
@@ -157,13 +160,21 @@ class AgentLLMModel(LLMModel):
                    kwargs['system'] = system_prompt

                # Pass context metadata to bot
-                channel_type = getattr(self, 'channel_type', None)
+                channel_type = getattr(self, 'channel_type', None) or ''
                if channel_type:
                    kwargs['channel_type'] = channel_type
                session_id = getattr(self, 'session_id', None)
                if session_id:
                    kwargs['session_id'] = session_id

+                # Determine thinking: respect global config, then channel_type
+                from config import conf
+                global_thinking = conf().get("enable_thinking", True)
+                if not global_thinking:
+                    kwargs['thinking'] = {"type": "disabled"}
+                else:
+                    kwargs['thinking'] = {"type": "enabled"} if channel_type == "web" else {"type": "disabled"}
+
                response = self.bot.call_with_tools(**kwargs)
                return self._format_response(response)
            else:
@@ -202,13 +213,21 @@ class AgentLLMModel(LLMModel):
                    kwargs['system'] = system_prompt

                # Pass context metadata to bot
-                channel_type = getattr(self, 'channel_type', None)
+                channel_type = getattr(self, 'channel_type', None) or ''
                if channel_type:
                    kwargs['channel_type'] = channel_type
                session_id = getattr(self, 'session_id', None)
                if session_id:
                    kwargs['session_id'] = session_id

+                # Determine thinking: respect global config, then channel_type
+                from config import conf
+                global_thinking = conf().get("enable_thinking", True)
+                if not global_thinking:
+                    kwargs['thinking'] = {"type": "disabled"}
+                else:
+                    kwargs['thinking'] = {"type": "enabled"} if channel_type == "web" else {"type": "disabled"}
+
                stream = self.bot.call_with_tools(**kwargs)
                
                # Convert stream format to our expected format
@@ -271,10 +290,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}")
@@ -493,22 +515,26 @@ class AgentBridge:
                reply.text_content = text_response
            return reply
        
-        # For other unknown file types, return text with file info
-        message = text_response or file_info.get("message", "文件已准备")
-        message += f"\n\n[文件: {file_info.get('file_name', file_path)}]"
-        return Reply(ReplyType.TEXT, message)
+        # For all other file types (tar.gz, zip, etc.), also use FILE type
+        file_url = f"file://{file_path}"
+        logger.info(f"[AgentBridge] Sending generic file: {file_url}")
+        reply = Reply(ReplyType.FILE, file_url)
+        reply.file_name = file_info.get("file_name", os.path.basename(file_path))
+        if text_response:
+            reply.text_content = text_response
+        return reply
    
    def _migrate_config_to_env(self, workspace_root: str):
        """
-        Migrate API keys from config.json to .env file if not already set
-        
+        Sync API keys from config.json to .env file.
+        Adds new keys and updates changed values on each startup.
+
        Args:
            workspace_root: Workspace directory path (not used, kept for compatibility)
        """
        from config import conf
        import os
        
-        # Mapping from config.json keys to environment variable names
        key_mapping = {
            "open_ai_api_key": "OPENAI_API_KEY",
            "open_ai_api_base": "OPENAI_API_BASE",
@@ -517,10 +543,9 @@ class AgentBridge:
            "linkai_api_key": "LINKAI_API_KEY",
        }
        
-        # Use fixed secure location for .env file
        env_file = expand_path("~/.cow/.env")
        
-        # Read existing env vars from .env file
+        # Read existing env vars (key -> value)
        existing_env_vars = {}
        if os.path.exists(env_file):
            try:
@@ -528,48 +553,46 @@ class AgentBridge:
                    for line in f:
                        line = line.strip()
                        if line and not line.startswith('#') and '=' in line:
-                            key, _ = line.split('=', 1)
-                            existing_env_vars[key.strip()] = True
+                            key, val = line.split('=', 1)
+                            existing_env_vars[key.strip()] = val.strip()
            except Exception as e:
                logger.warning(f"[AgentBridge] Failed to read .env file: {e}")
        
-        # Check which keys need to be migrated
-        keys_to_migrate = {}
+        # Sync config.json values into .env (add/update/remove)
+        updated = False
        for config_key, env_key in key_mapping.items():
-            # Skip if already in .env file
-            if env_key in existing_env_vars:
-                continue
-            
-            # Get value from config.json
-            value = conf().get(config_key, "")
-            if value and value.strip():  # Only migrate non-empty values
-                keys_to_migrate[env_key] = value.strip()
-        
-        # Log summary if there are keys to skip
-        if existing_env_vars:
-            logger.debug(f"[AgentBridge] {len(existing_env_vars)} env vars already in .env")
-        
-        # Write new keys to .env file
-        if keys_to_migrate:
+            raw = conf().get(config_key, "")
+            value = raw.strip() if raw else ""
+            old_value = existing_env_vars.get(env_key)
+
+            if value:
+                if old_value == value:
+                    continue
+                existing_env_vars[env_key] = value
+                os.environ[env_key] = value
+                updated = True
+            else:
+                if old_value is None:
+                    continue
+                existing_env_vars.pop(env_key, None)
+                os.environ.pop(env_key, None)
+                updated = True
+            updated = True
+
+        if updated:
            try:
-                # Ensure ~/.cow directory and .env file exist
                env_dir = os.path.dirname(env_file)
-                if not os.path.exists(env_dir):
-                    os.makedirs(env_dir, exist_ok=True)
-                if not os.path.exists(env_file):
-                    open(env_file, 'a').close()
-                
-                # Append new keys
-                with open(env_file, 'a', encoding='utf-8') as f:
-                    f.write('\n# Auto-migrated from config.json\n')
-                    for key, value in keys_to_migrate.items():
+                os.makedirs(env_dir, exist_ok=True)
+
+                with open(env_file, 'w', encoding='utf-8') as f:
+                    f.write('# Environment variables for agent\n')
+                    f.write('# Auto-managed - synced from config.json on startup\n\n')
+                    for key, value in sorted(existing_env_vars.items()):
                        f.write(f'{key}={value}\n')
-                        # Also set in current process
-                        os.environ[key] = value
-                
-                logger.info(f"[AgentBridge] Migrated {len(keys_to_migrate)} API keys from config.json to .env: {list(keys_to_migrate.keys())}")
+
+                logger.info(f"[AgentBridge] Synced API keys from config.json to .env")
            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to migrate API keys: {e}")
+                logger.warning(f"[AgentBridge] Failed to sync API keys: {e}")
    
    def _persist_messages(
        self, session_id: str, new_messages: list, channel_type: str = ""
--- a/bridge/agent_event_handler.py
+++ b/bridge/agent_event_handler.py
@@ -26,8 +26,7 @@ class AgentEventHandler:
        if context:
            self.channel = context.kwargs.get("channel") if hasattr(context, "kwargs") else None
        
-        # Track current thinking for channel output
-        self.current_thinking = ""
+        self.current_content = ""
        self.turn_number = 0
    
    def handle_event(self, event):
@@ -47,6 +46,8 @@ class AgentEventHandler:
            self._handle_message_update(data)
        elif event_type == "message_end":
            self._handle_message_end(data)
+        elif event_type == "reasoning_update":
+            pass
        elif event_type == "tool_execution_start":
            self._handle_tool_execution_start(data)
        elif event_type == "tool_execution_end":
@@ -59,30 +60,26 @@ class AgentEventHandler:
    def _handle_turn_start(self, data):
        """Handle turn start event"""
        self.turn_number = data.get("turn", 0)
-        self.has_tool_calls_in_turn = False
-        self.current_thinking = ""
+        self.current_content = ""
    
    def _handle_message_update(self, data):
-        """Handle message update event (streaming text)"""
+        """Handle message update event (streaming content text)"""
        delta = data.get("delta", "")
-        self.current_thinking += delta
+        self.current_content += delta
    
    def _handle_message_end(self, data):
        """Handle message end event"""
        tool_calls = data.get("tool_calls", [])
        
-        # Only send thinking process if followed by tool calls
        if tool_calls:
-            if self.current_thinking.strip():
-                logger.info(f"💭 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}")
-                # Send thinking process to channel
-                self._send_to_channel(f"{self.current_thinking.strip()}")
+            if self.current_content.strip():
+                logger.info(f"💭 {self.current_content.strip()[:200]}{'...' if len(self.current_content) > 200 else ''}")
+                self._send_to_channel(self.current_content.strip())
        else:
-            # No tool calls = final response (logged at agent_stream level)
-            if self.current_thinking.strip():
-                logger.debug(f"💬 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}")
+            if self.current_content.strip():
+                logger.debug(f"💬 {self.current_content.strip()[:200]}{'...' if len(self.current_content) > 200 else ''}")
        
-        self.current_thinking = ""
+        self.current_content = ""
    
    def _handle_tool_execution_start(self, data):
        """Handle tool execution start event - logged by agent_stream.py"""
--- a/bridge/agent_initializer.py
+++ b/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:
@@ -465,8 +465,12 @@ class AgentInitializer:
                'timezone': timezone_name
            }
        
+        def get_model():
+            """Get current model name dynamically from config"""
+            return conf().get("model", "unknown")
+
        return {
-            "model": conf().get("model", "unknown"),
+            "_get_model": get_model,
            "workspace": workspace_root,
            "channel": ", ".join(conf().get("channel_type")) if isinstance(conf().get("channel_type"), list) else conf().get("channel_type", "unknown"),
            "_get_current_time": get_current_time  # Dynamic time function
@@ -486,7 +490,7 @@ class AgentInitializer:
        
        env_file = expand_path("~/.cow/.env")
        
-        # Read existing env vars
+        # Read existing env vars (key -> value)
        existing_env_vars = {}
        if os.path.exists(env_file):
            try:
@@ -494,38 +498,46 @@ class AgentInitializer:
                    for line in f:
                        line = line.strip()
                        if line and not line.startswith('#') and '=' in line:
-                            key, _ = line.split('=', 1)
-                            existing_env_vars[key.strip()] = True
+                            key, val = line.split('=', 1)
+                            existing_env_vars[key.strip()] = val.strip()
            except Exception as e:
                logger.warning(f"[AgentInitializer] Failed to read .env file: {e}")
        
-        # Check which keys need migration
-        keys_to_migrate = {}
+        # Sync config.json values into .env (add/update/remove)
+        updated = False
        for config_key, env_key in key_mapping.items():
-            if env_key in existing_env_vars:
-                continue
-            value = conf().get(config_key, "")
-            if value and value.strip():
-                keys_to_migrate[env_key] = value.strip()
-        
-        # Write new keys
-        if keys_to_migrate:
+            raw = conf().get(config_key, "")
+            value = raw.strip() if raw else ""
+            old_value = existing_env_vars.get(env_key)
+
+            if value:
+                if old_value == value:
+                    continue
+                existing_env_vars[env_key] = value
+                os.environ[env_key] = value
+                updated = True
+            else:
+                if old_value is None:
+                    continue
+                existing_env_vars.pop(env_key, None)
+                os.environ.pop(env_key, None)
+                updated = True
+
+        if updated:
            try:
                env_dir = os.path.dirname(env_file)
-                if not os.path.exists(env_dir):
-                    os.makedirs(env_dir, exist_ok=True)
-                if not os.path.exists(env_file):
-                    open(env_file, 'a').close()
-                
-                with open(env_file, 'a', encoding='utf-8') as f:
-                    f.write('\n# Auto-migrated from config.json\n')
-                    for key, value in keys_to_migrate.items():
+                os.makedirs(env_dir, exist_ok=True)
+
+                # Rewrite the entire .env file to ensure consistency
+                with open(env_file, 'w', encoding='utf-8') as f:
+                    f.write('# Environment variables for agent\n')
+                    f.write('# Auto-managed - synced from config.json on startup\n\n')
+                    for key, value in sorted(existing_env_vars.items()):
                        f.write(f'{key}={value}\n')
-                        os.environ[key] = value
-                
-                logger.info(f"[AgentInitializer] Migrated {len(keys_to_migrate)} API keys to .env: {list(keys_to_migrate.keys())}")
+
+                logger.info(f"[AgentInitializer] Synced API keys from config.json to .env")
            except Exception as e:
-                logger.warning(f"[AgentInitializer] Failed to migrate API keys: {e}")
+                logger.warning(f"[AgentInitializer] Failed to sync API keys: {e}")

    def _start_daily_flush_timer(self):
        """Start a background thread that flushes all agents' memory daily at 23:55."""
@@ -555,7 +567,7 @@ class AgentInitializer:
        t.start()

    def _flush_all_agents(self):
-        """Flush memory for all active agent sessions."""
+        """Flush memory for all active agent sessions, then run Deep Dream."""
        agents = []
        if self.agent_bridge.default_agent:
            agents.append(("default", self.agent_bridge.default_agent))
@@ -565,7 +577,10 @@ class AgentInitializer:
        if not agents:
            return

+        # Phase 1: flush daily summaries
        flushed = 0
+        flush_threads = []
+        dream_candidate = None
        for label, agent in agents:
            try:
                if not agent.memory_manager:
@@ -577,8 +592,26 @@ class AgentInitializer:
                result = agent.memory_manager.flush_manager.create_daily_summary(messages)
                if result:
                    flushed += 1
+                    t = agent.memory_manager.flush_manager._last_flush_thread
+                    if t:
+                        flush_threads.append(t)
+                if dream_candidate is None:
+                    dream_candidate = agent.memory_manager.flush_manager
            except Exception as e:
                logger.warning(f"[DailyFlush] Failed for session {label}: {e}")

        if flushed:
            logger.info(f"[DailyFlush] Flushed {flushed}/{len(agents)} agent session(s)")
+
+        # Wait for all flush threads to finish before dreaming
+        for t in flush_threads:
+            t.join(timeout=60)
+
+        # Phase 2: Deep Dream — distill daily memories → MEMORY.md + dream diary
+        if dream_candidate:
+            try:
+                result = dream_candidate.deep_dream()
+                if result:
+                    logger.info("[DeepDream] Memory distillation completed successfully")
+            except Exception as e:
+                logger.warning(f"[DeepDream] Failed: {e}")
--- a/bridge/bridge.py
+++ b/bridge/bridge.py
@@ -39,11 +39,8 @@ class Bridge(object):
                self.btype["chat"] = const.BAIDU
            if model_type in ["xunfei"]:
                self.btype["chat"] = const.XUNFEI
-            if model_type in [const.QWEN]:
-                self.btype["chat"] = const.QWEN
-            if model_type in [const.QWEN_TURBO, const.QWEN_PLUS, const.QWEN_MAX]:
+            if model_type in [const.QWEN, const.QWEN_TURBO, const.QWEN_PLUS, const.QWEN_MAX]:
                self.btype["chat"] = const.QWEN_DASHSCOPE
-            # Support Qwen3 and other DashScope models
            if model_type and (model_type.startswith("qwen") or model_type.startswith("qwq") or model_type.startswith("qvq")):
                self.btype["chat"] = const.QWEN_DASHSCOPE
            if model_type and model_type.startswith("gemini"):
--- a/channel/chat_channel.py
+++ b/channel/chat_channel.py
@@ -347,38 +347,30 @@ class ChatChannel(Channel):
        if media_items:
            logger.info(f"[chat_channel] Extracted {len(media_items)} media item(s) from reply")
            
-            # 先发送文本（保持原文本不变）
+            # Send text first (the frontend will embed video players via renderMarkdown).
            logger.info(f"[chat_channel] Sending text content before media: {reply.content[:100]}...")
            self._send(reply, context)
            logger.info(f"[chat_channel] Text sent, now sending {len(media_items)} media item(s)")
            
-            # 然后逐个发送媒体文件
            for i, (url, media_type) in enumerate(media_items):
                try:
-                    # 判断是本地文件还是URL
+                    # Determine whether it is a remote URL or a local file.
                    if url.startswith(('http://', 'https://')):
-                        # 网络资源
                        if media_type == 'video':
-                            # 视频使用 FILE 类型发送
                            media_reply = Reply(ReplyType.FILE, url)
                            media_reply.file_name = os.path.basename(url)
                        else:
-                            # 图片使用 IMAGE_URL 类型
                            media_reply = Reply(ReplyType.IMAGE_URL, url)
                    elif os.path.exists(url):
-                        # 本地文件
                        if media_type == 'video':
-                            # 视频使用 FILE 类型，转换为 file:// URL
                            media_reply = Reply(ReplyType.FILE, f"file://{url}")
                            media_reply.file_name = os.path.basename(url)
                        else:
-                            # 图片使用 IMAGE_URL 类型，转换为 file:// URL
                            media_reply = Reply(ReplyType.IMAGE_URL, f"file://{url}")
                    else:
                        logger.warning(f"[chat_channel] Media file not found or invalid URL: {url}")
                        continue
                    
-                    # 发送媒体文件（添加小延迟避免频率限制）
                    if i > 0:
                        time.sleep(0.5)
                    self._send(media_reply, context)
--- a/channel/web/chat.html
+++ b/channel/web/chat.html
@@ -50,16 +50,53 @@
    (function() {
        var theme = localStorage.getItem('cow_theme') || 'dark';
        if (theme === 'dark') document.documentElement.classList.add('dark');
+        var lang = localStorage.getItem('cow_lang') || 'zh';
+        document.documentElement.setAttribute('lang', lang);
    })();
    </script>
 </head>
 <body class="h-screen overflow-hidden bg-gray-50 dark:bg-[#111111] text-slate-800 dark:text-slate-200 font-sans">
+
+    <!-- Login Overlay -->
+    <div id="login-overlay" class="fixed inset-0 z-[200] bg-gray-50 dark:bg-[#111111] flex items-center justify-center hidden">
+        <div class="w-full max-w-sm mx-4">
+            <div class="flex flex-col items-center mb-8">
+                <img src="assets/logo.jpg" alt="CowAgent" class="w-16 h-16 rounded-2xl mb-4 shadow-lg">
+                <h1 class="text-xl font-bold text-slate-800 dark:text-slate-100">CowAgent</h1>
+                <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" id="login-subtitle">请输入密码以访问控制台</p>
+            </div>
+            <form id="login-form" class="space-y-4" onsubmit="return false;">
+                <div class="relative">
+                    <input id="login-password" type="password" autocomplete="current-password"
+                           placeholder="Password"
+                           class="w-full px-4 py-3 rounded-xl border border-slate-200 dark:border-white/10
+                                  bg-white dark:bg-[#1A1A1A] text-slate-800 dark:text-slate-200
+                                  placeholder-slate-400 dark:placeholder-slate-500
+                                  focus:outline-none focus:ring-2 focus:ring-primary-400/50 focus:border-primary-400
+                                  transition-all duration-150 text-sm">
+                    <button type="button" id="login-toggle-pwd"
+                            class="absolute right-3 top-1/2 -translate-y-1/2 text-slate-400 hover:text-slate-600
+                                   dark:hover:text-slate-300 cursor-pointer transition-colors"
+                            onclick="toggleLoginPassword()">
+                        <i class="fas fa-eye text-sm"></i>
+                    </button>
+                </div>
+                <p id="login-error" class="text-sm text-red-500 hidden"></p>
+                <button id="login-btn" type="submit"
+                        class="w-full py-3 rounded-xl bg-primary-500 hover:bg-primary-600 text-white font-medium
+                               text-sm cursor-pointer transition-colors duration-150 disabled:opacity-50 disabled:cursor-not-allowed">
+                    登录
+                </button>
+            </form>
+        </div>
+    </div>
+
    <div id="app" class="flex h-screen">

        <!-- ================================================================ -->
        <!-- SIDEBAR                                                          -->
        <!-- ================================================================ -->
-        <aside id="sidebar" class="fixed inset-y-0 left-0 z-50 w-64 bg-[#0A0A0A] text-neutral-400 flex flex-col
+        <aside id="sidebar" class="fixed inset-y-0 left-0 z-50 w-52 bg-[#0A0A0A] text-neutral-400 flex flex-col
                                    transform -translate-x-full lg:relative lg:translate-x-0
                                    transition-transform duration-300 ease-in-out">
            <!-- Logo -->
@@ -67,7 +104,7 @@
                <img src="assets/logo.jpg" alt="CowAgent" class="w-8 h-8 rounded-lg flex-shrink-0">
                <div class="flex flex-col min-w-0">
                    <span class="text-white font-semibold text-sm truncate">CowAgent</span>
-                    <span class="text-neutral-500 text-xs" data-i18n="console">Console</span>
+                    <span class="text-neutral-500 text-xs" data-i18n="console">控制台</span>
                </div>
            </div>

@@ -77,13 +114,13 @@
                <div class="menu-group open" data-group="chat">
                    <button class="w-full flex items-center gap-2 px-3 py-2 text-xs font-semibold uppercase tracking-wider text-neutral-500 hover:text-neutral-300 cursor-pointer transition-colors duration-150">
                        <i class="fas fa-chevron-right text-[10px] chevron"></i>
-                        <span data-i18n="nav_chat">Chat</span>
+                        <span data-i18n="nav_chat">对话</span>
                    </button>
                    <div class="menu-group-items pl-2">
                        <a class="sidebar-item active flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="chat">
                            <i class="fas fa-message item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_chat">Chat</span>
+                            <span data-i18n="menu_chat">对话</span>
                        </a>
                    </div>
                </div>
@@ -92,33 +129,38 @@
                <div class="menu-group open" data-group="manage">
                    <button class="w-full flex items-center gap-2 px-3 py-2 text-xs font-semibold uppercase tracking-wider text-neutral-500 hover:text-neutral-300 cursor-pointer transition-colors duration-150">
                        <i class="fas fa-chevron-right text-[10px] chevron"></i>
-                        <span data-i18n="nav_manage">Management</span>
+                        <span data-i18n="nav_manage">管理</span>
                    </button>
                    <div class="menu-group-items pl-2">
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="config">
                            <i class="fas fa-sliders item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_config">Config</span>
+                            <span data-i18n="menu_config">配置</span>
                        </a>
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="skills">
                            <i class="fas fa-bolt item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_skills">Skills</span>
+                            <span data-i18n="menu_skills">技能</span>
                        </a>
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="memory">
                            <i class="fas fa-brain item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_memory">Memory</span>
+                            <span data-i18n="menu_memory">记忆</span>
+                        </a>
+                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
+                           data-view="knowledge">
+                            <i class="fas fa-book item-icon text-xs w-5 text-center"></i>
+                            <span data-i18n="menu_knowledge">知识</span>
                        </a>
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="channels">
                            <i class="fas fa-tower-broadcast item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_channels">Channels</span>
+                            <span data-i18n="menu_channels">通道</span>
                        </a>
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="tasks">
                            <i class="fas fa-clock item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_tasks">Tasks</span>
+                            <span data-i18n="menu_tasks">定时</span>
                        </a>
                    </div>
                </div>
@@ -127,13 +169,13 @@
                <div class="menu-group open" data-group="monitor">
                    <button class="w-full flex items-center gap-2 px-3 py-2 text-xs font-semibold uppercase tracking-wider text-neutral-500 hover:text-neutral-300 cursor-pointer transition-colors duration-150">
                        <i class="fas fa-chevron-right text-[10px] chevron"></i>
-                        <span data-i18n="nav_monitor">Monitor</span>
+                        <span data-i18n="nav_monitor">监控</span>
                    </button>
                    <div class="menu-group-items pl-2">
                        <a class="sidebar-item flex items-center gap-3 px-3 py-2 rounded-lg cursor-pointer transition-all duration-150 hover:bg-white/5 hover:text-neutral-200 text-[14px]"
                           data-view="logs">
                            <i class="fas fa-terminal item-icon text-xs w-5 text-center"></i>
-                            <span data-i18n="menu_logs">Logs</span>
+                            <span data-i18n="menu_logs">日志</span>
                        </a>
                    </div>
                </div>
@@ -154,6 +196,23 @@
        <!-- Mobile Overlay -->
        <div id="sidebar-overlay" class="fixed inset-0 bg-black/50 z-40 hidden lg:hidden cursor-pointer" onclick="toggleSidebar()"></div>

+        <!-- ================================================================ -->
+        <!-- SESSION PANEL (collapsible)                                      -->
+        <!-- ================================================================ -->
+        <aside id="session-panel" class="session-panel hidden">
+            <div class="session-panel-header">
+                <span class="session-panel-title" data-i18n="session_history">历史会话</span>
+                <button class="session-panel-close" onclick="toggleSessionPanel()" title="Close">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+            <button class="session-panel-new" onclick="newChat()">
+                <i class="fas fa-plus"></i>
+                <span data-i18n="new_chat">新对话</span>
+            </button>
+            <div id="session-list" class="session-list"></div>
+        </aside>
+
        <!-- ================================================================ -->
        <!-- MAIN CONTENT                                                     -->
        <!-- ================================================================ -->
@@ -166,11 +225,17 @@
                    <i class="fas fa-bars text-slate-600 dark:text-slate-300"></i>
                </button>

+                <!-- Session panel toggle -->
+                <button id="session-toggle-btn" class="p-2 rounded-lg hover:bg-slate-100 dark:hover:bg-white/10 cursor-pointer transition-colors duration-150"
+                        onclick="toggleSessionPanel()">
+                    <i class="fas fa-clock-rotate-left text-slate-500 dark:text-slate-400"></i>
+                </button>
+
                <!-- 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>
+                    <span id="breadcrumb-group" class="text-slate-400 dark:text-slate-500 truncate" data-i18n="nav_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>
+                    <span id="breadcrumb-page" class="font-medium text-slate-700 dark:text-slate-200 truncate" data-i18n="menu_chat">对话</span>
                </div>

                <div class="flex-1"></div>
@@ -224,22 +289,22 @@
                    <!-- Messages -->
                    <div id="chat-messages" class="flex-1 overflow-y-auto">
                        <!-- Welcome Screen -->
-                        <div id="welcome-screen" class="flex flex-col items-center justify-center h-full px-6 py-12">
+                        <div id="welcome-screen" class="flex flex-col items-center justify-center h-full px-6 pb-16" style="padding-top: 6vh">
                            <img src="assets/logo.jpg" alt="CowAgent" class="w-16 h-16 rounded-2xl mb-6 shadow-lg shadow-primary-500/20">
                            <h1 id="welcome-title" class="text-2xl font-bold text-slate-800 dark:text-slate-100 mb-3">CowAgent</h1>
                            <p id="welcome-subtitle" class="text-slate-500 dark:text-slate-400 text-center max-w-lg mb-10 leading-relaxed"
-                               data-i18n-html="welcome_subtitle">I can help you answer questions, manage your computer, create and execute skills,<br>and keep growing through long-term memory.</p>
+                               data-i18n-html="welcome_subtitle">我可以帮你解答问题、管理计算机、创造和执行技能，并通过<br>长期记忆和知识库不断成长</p>

-                            <div class="grid grid-cols-1 sm:grid-cols-3 gap-4 w-full max-w-2xl">
+                            <div class="grid grid-cols-2 sm:grid-cols-3 gap-3 w-full max-w-2xl">
                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200">
                                    <div class="flex items-center gap-2 mb-2">
                                        <div class="w-7 h-7 rounded-lg bg-blue-50 dark:bg-blue-900/30 flex items-center justify-center">
                                            <i class="fas fa-folder-open text-blue-500 text-xs"></i>
                                        </div>
-                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_sys_title">System</span>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_sys_title">系统管理</span>
                                    </div>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_sys_text">Show me the files in the workspace</p>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_sys_text">查看工作空间里有哪些文件</p>
                                </div>
                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200">
@@ -247,9 +312,9 @@
                                        <div class="w-7 h-7 rounded-lg bg-amber-50 dark:bg-amber-900/30 flex items-center justify-center">
                                            <i class="fas fa-clock text-amber-500 text-xs"></i>
                                        </div>
-                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_task_title">Smart Task</span>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_task_title">定时任务</span>
                                    </div>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_task_text">Remind me to check the server in 5 minutes</p>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_task_text">1分钟后提醒我检查服务器</p>
                                </div>
                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200">
@@ -257,9 +322,40 @@
                                        <div class="w-7 h-7 rounded-lg bg-emerald-50 dark:bg-emerald-900/30 flex items-center justify-center">
                                            <i class="fas fa-code text-emerald-500 text-xs"></i>
                                        </div>
-                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_code_title">Coding</span>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_code_title">编程助手</span>
                                    </div>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_code_text">Write a Python web scraper script</p>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_code_text">搜索AI资讯并生成可视化网页报告</p>
+                                </div>
+                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
+                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200">
+                                    <div class="flex items-center gap-2 mb-2">
+                                        <div class="w-7 h-7 rounded-lg bg-violet-50 dark:bg-violet-900/30 flex items-center justify-center">
+                                            <i class="fas fa-book text-violet-500 text-xs"></i>
+                                        </div>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_knowledge_title">知识库</span>
+                                    </div>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_knowledge_text">查看知识库当前文档情况</p>
+                                </div>
+                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
+                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200">
+                                    <div class="flex items-center gap-2 mb-2">
+                                        <div class="w-7 h-7 rounded-lg bg-rose-50 dark:bg-rose-900/30 flex items-center justify-center">
+                                            <i class="fas fa-puzzle-piece text-rose-500 text-xs"></i>
+                                        </div>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_skill_title">技能系统</span>
+                                    </div>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_skill_text">查看所有支持的工具和技能</p>
+                                </div>
+                                <div class="example-card group bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-xl p-4
+                                            cursor-pointer hover:border-primary-300 dark:hover:border-primary-600 hover:shadow-md transition-all duration-200"
+                                     data-send="/help">
+                                    <div class="flex items-center gap-2 mb-2">
+                                        <div class="w-7 h-7 rounded-lg bg-slate-100 dark:bg-slate-800 flex items-center justify-center">
+                                            <i class="fas fa-terminal text-slate-500 text-xs"></i>
+                                        </div>
+                                        <span class="font-medium text-sm text-slate-700 dark:text-slate-200" data-i18n="example_web_title">指令中心</span>
+                                    </div>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 leading-relaxed" data-i18n="example_web_text">查看全部命令</p>
                                </div>
                            </div>
                        </div>
@@ -274,14 +370,20 @@
                                <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
-                                                                     cursor-pointer transition-colors duration-150" title="New Chat"
+                                                                     cursor-pointer transition-colors duration-150"
                                            onclick="newChat()">
                                        <i class="fas fa-plus text-base"></i>
                                    </button>
+                                    <button id="clear-context-btn" class="w-9 h-10 flex items-center justify-center rounded-lg
+                                                                          text-slate-400 hover:text-amber-500 hover:bg-amber-50 dark:hover:bg-amber-900/20
+                                                                          cursor-pointer transition-colors duration-150"
+                                            onclick="clearContext()">
+                                        <i class="fas fa-trash-can text-base"></i>
+                                    </button>
                                    <button id="attach-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
                                                                   cursor-pointer transition-colors duration-150"
-                                            title="Attach file" onclick="document.getElementById('file-input').click()">
+                                            onclick="document.getElementById('file-input').click()">
                                        <i class="fas fa-paperclip text-base"></i>
                                    </button>
                                </div>
@@ -296,7 +398,7 @@
                                                 text-sm leading-relaxed"
                                          rows="1"
                                          data-i18n-placeholder="input_placeholder"
-                                          placeholder="Type a message, or press / for commands"></textarea>
+                                          placeholder="输入消息，或输入 / 使用指令"></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
@@ -318,8 +420,8 @@
                        <div class="max-w-4xl mx-auto">
                            <div class="flex items-center justify-between mb-6">
                                <div>
-                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="config_title">Configuration</h2>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="config_desc">Manage model and agent settings</p>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="config_title">配置管理</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="config_desc">管理模型和 Agent 配置</p>
                                </div>
                            </div>
                            <div class="grid gap-6">
@@ -330,12 +432,12 @@
                                        <div class="w-9 h-9 rounded-lg bg-primary-50 dark:bg-primary-900/30 flex items-center justify-center">
                                            <i class="fas fa-microchip text-primary-500 text-sm"></i>
                                        </div>
-                                        <h3 class="font-semibold text-slate-800 dark:text-slate-100" data-i18n="config_model">Model Configuration</h3>
+                                        <h3 class="font-semibold text-slate-800 dark:text-slate-100" data-i18n="config_model">模型配置</h3>
                                    </div>
                                    <div class="space-y-5">
                                        <!-- Provider -->
                                        <div>
-                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_provider">Provider</label>
+                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_provider">模型厂商</label>
                                            <div id="cfg-provider" class="cfg-dropdown" tabindex="0">
                                                <div class="cfg-dropdown-selected">
                                                    <span class="cfg-dropdown-text">--</span>
@@ -346,7 +448,7 @@
                                        </div>
                                        <!-- Model -->
                                        <div>
-                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_model_name">Model</label>
+                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_model_name">模型</label>
                                            <div id="cfg-model-select" class="cfg-dropdown" tabindex="0">
                                                <div class="cfg-dropdown-selected">
                                                    <span class="cfg-dropdown-text">--</span>
@@ -359,7 +461,7 @@
                                                       class="w-full px-3 py-2 rounded-lg border border-slate-200 dark:border-slate-600
                                                              bg-slate-50 dark:bg-white/5 text-sm text-slate-800 dark:text-slate-100
                                                              focus:outline-none focus:border-primary-500 font-mono transition-colors"
-                                                       data-i18n-placeholder="config_custom_model_hint" placeholder="Enter custom model name">
+                                                       data-i18n-placeholder="config_custom_model_hint" placeholder="输入自定义模型名称">
                                            </div>
                                        </div>
                                        <!-- API Key -->
@@ -394,7 +496,7 @@
                                            <button id="cfg-model-save"
                                                    class="px-4 py-2 rounded-lg bg-primary-500 hover:bg-primary-600 text-white text-sm font-medium
                                                           cursor-pointer transition-colors duration-150 disabled:opacity-50 disabled:cursor-not-allowed"
-                                                    onclick="saveModelConfig()" data-i18n="config_save">Save</button>
+                                                    onclick="saveModelConfig()" data-i18n="config_save">保存</button>
                                        </div>
                                    </div>
                                </div>
@@ -405,36 +507,86 @@
                                        <div class="w-9 h-9 rounded-lg bg-emerald-50 dark:bg-emerald-900/30 flex items-center justify-center">
                                            <i class="fas fa-robot text-emerald-500 text-sm"></i>
                                        </div>
-                                        <h3 class="font-semibold text-slate-800 dark:text-slate-100" data-i18n="config_agent">Agent Configuration</h3>
+                                        <h3 class="font-semibold text-slate-800 dark:text-slate-100" data-i18n="config_agent">Agent 配置</h3>
                                    </div>
                                    <div class="space-y-4">
                                        <div>
-                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_max_tokens">Max Context Tokens</label>
+                                            <label class="flex items-center gap-1.5 text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5">
+                                                <span data-i18n="config_max_tokens">最大上下文 Token</span>
+                                                <span class="cfg-tip" data-tip-key="config_max_tokens_hint"><i class="fas fa-circle-question"></i></span>
+                                            </label>
                                            <input id="cfg-max-tokens" type="number" min="1000" max="200000" step="1000"
                                                   class="w-full px-3 py-2 rounded-lg border border-slate-200 dark:border-slate-600
                                                          bg-slate-50 dark:bg-white/5 text-sm text-slate-800 dark:text-slate-100
                                                          focus:outline-none focus:border-primary-500 font-mono transition-colors">
                                        </div>
                                        <div>
-                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_max_turns">Max Context Turns</label>
+                                            <label class="flex items-center gap-1.5 text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5">
+                                                <span data-i18n="config_max_turns">最大记忆轮次</span>
+                                                <span class="cfg-tip" data-tip-key="config_max_turns_hint"><i class="fas fa-circle-question"></i></span>
+                                            </label>
                                            <input id="cfg-max-turns" type="number" min="1" max="100" step="1"
                                                   class="w-full px-3 py-2 rounded-lg border border-slate-200 dark:border-slate-600
                                                          bg-slate-50 dark:bg-white/5 text-sm text-slate-800 dark:text-slate-100
                                                          focus:outline-none focus:border-primary-500 font-mono transition-colors">
                                        </div>
                                        <div>
-                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_max_steps">Max Steps</label>
+                                            <label class="flex items-center gap-1.5 text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5">
+                                                <span data-i18n="config_max_steps">最大执行步数</span>
+                                                <span class="cfg-tip" data-tip-key="config_max_steps_hint"><i class="fas fa-circle-question"></i></span>
+                                            </label>
                                            <input id="cfg-max-steps" type="number" min="1" max="50" step="1"
                                                   class="w-full px-3 py-2 rounded-lg border border-slate-200 dark:border-slate-600
                                                          bg-slate-50 dark:bg-white/5 text-sm text-slate-800 dark:text-slate-100
                                                          focus:outline-none focus:border-primary-500 font-mono transition-colors">
                                        </div>
+                                        <div class="flex items-center justify-between">
+                                            <label class="flex items-center gap-1.5 text-sm font-medium text-slate-600 dark:text-slate-400">
+                                                <span data-i18n="config_enable_thinking">Deep Thinking</span>
+                                                <span class="cfg-tip" data-tip-key="config_enable_thinking_hint"><i class="fas fa-circle-question"></i></span>
+                                            </label>
+                                            <label class="relative inline-flex items-center cursor-pointer">
+                                                <input id="cfg-enable-thinking" type="checkbox" class="sr-only peer" checked>
+                                                <div class="w-9 h-5 bg-slate-200 dark:bg-slate-700 peer-checked:bg-primary-400 rounded-full
+                                                            after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white
+                                                            after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:after:translate-x-full"></div>
+                                            </label>
+                                        </div>
                                        <div class="flex items-center justify-end gap-3 pt-1">
                                            <span id="cfg-agent-status" class="text-xs text-primary-500 opacity-0 transition-opacity duration-300"></span>
                                            <button id="cfg-agent-save"
                                                    class="px-4 py-2 rounded-lg bg-primary-500 hover:bg-primary-600 text-white text-sm font-medium
                                                           cursor-pointer transition-colors duration-150 disabled:opacity-50 disabled:cursor-not-allowed"
-                                                    onclick="saveAgentConfig()" data-i18n="config_save">Save</button>
+                                                    onclick="saveAgentConfig()" data-i18n="config_save">保存</button>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <!-- Security Config Card -->
+                                <div class="bg-white dark:bg-[#1A1A1A] rounded-xl border border-slate-200 dark:border-white/10 p-6">
+                                    <div class="flex items-center gap-3 mb-5">
+                                        <div class="w-9 h-9 rounded-lg bg-amber-50 dark:bg-amber-900/30 flex items-center justify-center">
+                                            <i class="fas fa-lock text-amber-500 text-sm"></i>
+                                        </div>
+                                        <h3 class="font-semibold text-slate-800 dark:text-slate-100" data-i18n="config_security">安全设置</h3>
+                                    </div>
+                                    <div class="space-y-4">
+                                        <div>
+                                            <label class="block text-sm font-medium text-slate-600 dark:text-slate-400 mb-1.5" data-i18n="config_password">访问密码</label>
+                                            <input id="cfg-password" type="password" autocomplete="new-password"
+                                                   class="w-full px-3 py-2 rounded-lg border border-slate-200 dark:border-slate-600
+                                                          bg-slate-50 dark:bg-white/5 text-sm text-slate-800 dark:text-slate-100
+                                                          focus:outline-none focus:border-primary-500 font-mono transition-colors
+                                                          cfg-key-masked"
+                                                   data-masked="1">
+                                            <p class="text-xs text-slate-400 dark:text-slate-500 mt-1.5" data-i18n="config_password_hint">留空则不启用密码保护</p>
+                                        </div>
+                                        <div class="flex items-center justify-end gap-3 pt-1">
+                                            <span id="cfg-password-status" class="text-xs text-primary-500 opacity-0 transition-opacity duration-300"></span>
+                                            <button id="cfg-password-save"
+                                                    class="px-4 py-2 rounded-lg bg-primary-500 hover:bg-primary-600 text-white text-sm font-medium
+                                                           cursor-pointer transition-colors duration-150 disabled:opacity-50 disabled:cursor-not-allowed"
+                                                    onclick="savePasswordConfig()" data-i18n="config_save">保存</button>
                                        </div>
                                    </div>
                                </div>
@@ -452,20 +604,25 @@
                        <div class="max-w-4xl mx-auto">
                            <div class="flex items-center justify-between mb-6">
                                <div>
-                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="skills_title">Skills</h2>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="skills_desc">View, enable, or disable agent skills</p>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="skills_title">技能管理</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="skills_desc">查看、启用或禁用 Agent 技能</p>
                                </div>
+                                <a href="https://skills.cowagent.ai/" target="_blank"
+                                   class="inline-flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-xs font-medium text-primary-500 bg-primary-50 dark:bg-primary-900/20 hover:bg-primary-100 dark:hover:bg-primary-900/30 transition-colors">
+                                    <i class="fas fa-puzzle-piece text-[10px]"></i>
+                                    <span data-i18n="skills_hub_btn">探索技能广场</span>
+                                </a>
                            </div>

                            <!-- Built-in Tools Section -->
                            <div class="mb-8">
                                <div class="flex items-center gap-2 mb-3">
-                                    <span class="text-xs font-semibold uppercase tracking-wider text-slate-400 dark:text-slate-500" data-i18n="tools_section_title">Built-in Tools</span>
+                                    <span class="text-xs font-semibold uppercase tracking-wider text-slate-400 dark:text-slate-500" data-i18n="tools_section_title">内置工具</span>
                                    <span id="tools-count-badge" class="hidden px-2 py-0.5 rounded-full text-xs bg-slate-100 dark:bg-white/10 text-slate-500 dark:text-slate-400"></span>
                                </div>
                                <div id="tools-empty" class="flex items-center gap-2 py-4 text-slate-400 dark:text-slate-500 text-sm">
                                    <i class="fas fa-spinner fa-spin text-xs"></i>
-                                    <span data-i18n="tools_loading">Loading tools...</span>
+                                    <span data-i18n="tools_loading">加载工具中...</span>
                                </div>
                                <div id="tools-list" class="grid gap-3 sm:grid-cols-2 hidden"></div>
                            </div>
@@ -473,15 +630,15 @@
                            <!-- Skills Section -->
                            <div>
                                <div class="flex items-center gap-2 mb-3">
-                                    <span class="text-xs font-semibold uppercase tracking-wider text-slate-400 dark:text-slate-500" data-i18n="skills_section_title">Skills</span>
+                                    <span class="text-xs font-semibold uppercase tracking-wider text-slate-400 dark:text-slate-500" data-i18n="skills_section_title">技能</span>
                                    <span id="skills-count-badge" class="hidden px-2 py-0.5 rounded-full text-xs bg-slate-100 dark:bg-white/10 text-slate-500 dark:text-slate-400"></span>
                                </div>
                                <div id="skills-empty" class="flex flex-col items-center justify-center py-12">
                                    <div class="w-14 h-14 rounded-2xl bg-amber-50 dark:bg-amber-900/20 flex items-center justify-center mb-3">
                                        <i class="fas fa-bolt text-amber-400 text-lg"></i>
                                    </div>
-                                    <p class="text-slate-500 dark:text-slate-400 font-medium" data-i18n="skills_loading">Loading skills...</p>
-                                    <p class="text-sm text-slate-400 dark:text-slate-500 mt-1" data-i18n="skills_loading_desc">Skills will be displayed here after loading</p>
+                                    <p class="text-slate-500 dark:text-slate-400 font-medium" data-i18n="skills_loading">加载技能中...</p>
+                                    <p class="text-sm text-slate-400 dark:text-slate-500 mt-1" data-i18n="skills_loading_desc">技能加载后将显示在此处</p>
                                </div>
                                <div id="skills-list" class="grid gap-4 sm:grid-cols-2"></div>
                            </div>
@@ -500,26 +657,36 @@
                            <div id="memory-panel-list">
                                <div class="flex items-center justify-between mb-6">
                                    <div>
-                                        <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="memory_title">Memory</h2>
-                                        <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="memory_desc">View agent memory files and contents</p>
+                                        <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="memory_title">记忆管理</h2>
+                                        <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="memory_desc">查看 Agent 记忆文件和内容</p>
+                                    </div>
+                                    <div class="flex items-center bg-slate-100 dark:bg-white/10 rounded-lg p-0.5">
+                                        <button id="memory-tab-files" onclick="switchMemoryTab('files')"
+                                                class="memory-tab px-3 py-1.5 rounded-md text-xs font-medium cursor-pointer transition-colors duration-150 active">
+                                            <i class="fas fa-file-lines mr-1.5"></i><span data-i18n="memory_tab_files">记忆文件</span>
+                                        </button>
+                                        <button id="memory-tab-dreams" onclick="switchMemoryTab('dreams')"
+                                                class="memory-tab px-3 py-1.5 rounded-md text-xs font-medium cursor-pointer transition-colors duration-150">
+                                            <i class="fas fa-moon mr-1.5"></i><span data-i18n="memory_tab_dreams">梦境日记</span>
+                                        </button>
                                    </div>
                                </div>
                                <div id="memory-empty" class="flex flex-col items-center justify-center py-20">
                                    <div class="w-16 h-16 rounded-2xl bg-purple-50 dark:bg-purple-900/20 flex items-center justify-center mb-4">
                                        <i class="fas fa-brain text-purple-400 text-xl"></i>
                                    </div>
-                                    <p class="text-slate-500 dark:text-slate-400 font-medium" data-i18n="memory_loading">Loading memory files...</p>
-                                    <p class="text-sm text-slate-400 dark:text-slate-500 mt-1" data-i18n="memory_loading_desc">Memory files will be displayed here</p>
+                                    <p class="text-slate-500 dark:text-slate-400 font-medium" data-i18n="memory_loading">加载记忆文件中...</p>
+                                    <p class="text-sm text-slate-400 dark:text-slate-500 mt-1" data-i18n="memory_loading_desc">记忆文件将显示在此处</p>
                                </div>
                                <div id="memory-list" class="hidden">
                                    <div class="bg-white dark:bg-[#1A1A1A] rounded-xl border border-slate-200 dark:border-white/10 overflow-hidden">
                                        <table class="w-full">
                                            <thead>
                                                <tr class="border-b border-slate-200 dark:border-white/10">
-                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_name">Filename</th>
-                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_type">Type</th>
-                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_size">Size</th>
-                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_updated">Updated</th>
+                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_name">文件名</th>
+                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_type">类型</th>
+                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_size">大小</th>
+                                                    <th class="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wider text-slate-500 dark:text-slate-400" data-i18n="memory_col_updated">更新时间</th>
                                                </tr>
                                            </thead>
                                            <tbody id="memory-table-body"></tbody>
@@ -537,7 +704,7 @@
                                                   text-slate-500 dark:text-slate-400 hover:bg-slate-100 dark:hover:bg-white/10
                                                   border border-slate-200 dark:border-white/10 transition-colors cursor-pointer">
                                        <i class="fas fa-arrow-left text-xs"></i>
-                                        <span data-i18n="memory_back">Back</span>
+                                        <span data-i18n="memory_back">返回列表</span>
                                    </button>
                                    <h2 id="memory-viewer-title"
                                        class="text-base font-semibold text-slate-800 dark:text-slate-100 font-mono truncate"></h2>
@@ -553,6 +720,106 @@
                    </div>
                </div>

+                <!-- ====================================================== -->
+                <!-- VIEW: Knowledge                                         -->
+                <!-- ====================================================== -->
+                <div id="view-knowledge" class="view">
+                    <div class="flex-1 overflow-y-auto p-4 md:p-8 lg:p-10">
+                        <div class="w-full max-w-[1600px] mx-auto">
+
+                            <!-- Header -->
+                            <div class="flex flex-col sm:flex-row sm:items-center justify-between gap-3 mb-4 md:mb-6">
+                                <div>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="knowledge_title">知识库</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="knowledge_desc">浏览和探索你的知识库</p>
+                                </div>
+                                <div class="flex items-center gap-2">
+                                    <span id="knowledge-stats" class="text-xs text-slate-400 dark:text-slate-500 hidden sm:inline"></span>
+                                    <div class="flex items-center bg-slate-100 dark:bg-white/10 rounded-lg p-0.5">
+                                        <button id="knowledge-tab-docs" onclick="switchKnowledgeTab('docs')"
+                                                class="knowledge-tab px-3 py-1.5 rounded-md text-xs font-medium cursor-pointer transition-colors duration-150 active">
+                                            <i class="fas fa-folder-tree mr-1.5"></i><span data-i18n="knowledge_tab_docs">文档</span>
+                                        </button>
+                                        <button id="knowledge-tab-graph" onclick="switchKnowledgeTab('graph')"
+                                                class="knowledge-tab px-3 py-1.5 rounded-md text-xs font-medium cursor-pointer transition-colors duration-150">
+                                            <i class="fas fa-diagram-project mr-1.5"></i><span data-i18n="knowledge_tab_graph">图谱</span>
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- Empty state -->
+                            <div id="knowledge-empty" class="flex flex-col items-center justify-center py-20">
+                                <div class="w-16 h-16 rounded-2xl bg-emerald-50 dark:bg-emerald-900/20 flex items-center justify-center mb-4">
+                                    <i class="fas fa-book text-emerald-400 text-xl"></i>
+                                </div>
+                                <p class="text-slate-500 dark:text-slate-400 font-medium" data-i18n="knowledge_loading">加载知识库中...</p>
+                                <p class="text-sm text-slate-400 dark:text-slate-500 mt-1" data-i18n="knowledge_loading_desc">知识页面将显示在这里</p>
+                                <div id="knowledge-empty-guide" class="hidden mt-6 max-w-sm text-center">
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mb-4" data-i18n="knowledge_empty_guide">在对话中发送文档、链接或主题给 Agent，它会自动整理到你的知识库中。</p>
+                                    <button onclick="navigateTo('chat')"
+                                            class="inline-flex items-center gap-2 px-4 py-2 rounded-lg bg-primary-500 hover:bg-primary-600
+                                                   text-white text-sm font-medium cursor-pointer transition-colors duration-150">
+                                        <i class="fas fa-message text-xs"></i>
+                                        <span data-i18n="knowledge_go_chat">开始对话</span>
+                                    </button>
+                                </div>
+                            </div>
+
+                            <!-- Documents panel -->
+                            <div id="knowledge-panel-docs" class="hidden">
+                                <div class="flex flex-col md:flex-row gap-4 md:gap-6" style="min-height: calc(100vh - 220px)">
+                                    <!-- File tree -->
+                                    <div id="knowledge-sidebar" class="w-full md:w-72 lg:w-80 flex-shrink-0">
+                                        <div class="bg-white dark:bg-[#1A1A1A] rounded-xl border border-slate-200 dark:border-white/10 overflow-hidden">
+                                            <div class="px-4 py-3 border-b border-slate-200 dark:border-white/10">
+                                                <div class="relative">
+                                                    <i class="fas fa-search absolute left-3 top-1/2 -translate-y-1/2 text-slate-400 text-xs"></i>
+                                                    <input id="knowledge-search" type="text" placeholder="Search..."
+                                                           class="w-full pl-8 pr-3 py-1.5 text-xs bg-slate-50 dark:bg-white/5 border border-slate-200 dark:border-white/10 rounded-lg text-slate-700 dark:text-slate-200 placeholder-slate-400 dark:placeholder-slate-500 focus:outline-none focus:ring-1 focus:ring-primary-400/50"
+                                                           oninput="filterKnowledgeTree(this.value)">
+                                                </div>
+                                            </div>
+                                            <div id="knowledge-tree" class="p-2 overflow-y-auto max-h-[50vh] md:max-h-[calc(100vh-300px)]"></div>
+                                        </div>
+                                    </div>
+                                    <!-- Content viewer -->
+                                    <div class="flex-1 min-w-0">
+                                        <div id="knowledge-content-placeholder"
+                                             class="flex flex-col items-center justify-center py-20 text-slate-400 dark:text-slate-500">
+                                            <i class="fas fa-file-lines text-3xl mb-3 opacity-40"></i>
+                                            <p class="text-sm" data-i18n="knowledge_select_hint">选择一个文档查看</p>
+                                        </div>
+                                        <div id="knowledge-content-viewer" class="hidden">
+                                            <div class="bg-white dark:bg-[#1A1A1A] rounded-xl border border-slate-200 dark:border-white/10 overflow-hidden">
+                                                <div class="flex items-center gap-3 px-4 md:px-5 py-3 border-b border-slate-200 dark:border-white/10">
+                                                    <button onclick="knowledgeMobileBack()" class="md:hidden p-1 -ml-1 text-slate-400 hover:text-slate-600 dark:hover:text-slate-300 cursor-pointer">
+                                                        <i class="fas fa-arrow-left text-xs"></i>
+                                                    </button>
+                                                    <i class="fas fa-file-lines text-slate-400 text-sm hidden md:inline"></i>
+                                                    <span id="knowledge-viewer-title" class="text-sm font-medium text-slate-700 dark:text-slate-200 truncate"></span>
+                                                    <span id="knowledge-viewer-path" class="text-xs text-slate-400 dark:text-slate-500 ml-auto font-mono truncate hidden md:inline"></span>
+                                                </div>
+                                                <div id="knowledge-viewer-body"
+                                                     class="p-4 md:p-5 overflow-y-auto text-sm msg-content text-slate-700 dark:text-slate-200"
+                                                     style="max-height: calc(100vh - 280px)"></div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- Graph panel -->
+                            <div id="knowledge-panel-graph" class="hidden">
+                                <div class="bg-white dark:bg-[#1A1A1A] rounded-xl border border-slate-200 dark:border-white/10 overflow-hidden">
+                                    <div id="knowledge-graph-container" class="w-full h-[60vh] md:h-[calc(100vh-220px)]"></div>
+                                </div>
+                            </div>
+
+                        </div>
+                    </div>
+                </div>
+
                <!-- ====================================================== -->
                <!-- VIEW: Channels                                          -->
                <!-- ====================================================== -->
@@ -561,14 +828,14 @@
                        <div class="max-w-4xl mx-auto">
                            <div class="flex items-center justify-between mb-6">
                                <div>
-                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="channels_title">Channels</h2>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="channels_desc">View and manage messaging channels</p>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="channels_title">通道管理</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="channels_desc">管理已接入的消息通道</p>
                                </div>
                                <button id="add-channel-btn" onclick="openAddChannelPanel()"
                                        class="flex items-center gap-2 px-4 py-2 rounded-lg bg-primary-500 hover:bg-primary-600
                                               text-white text-sm font-medium cursor-pointer transition-colors duration-150">
                                    <i class="fas fa-plus text-xs"></i>
-                                    <span data-i18n="channels_add">Connect</span>
+                                    <span data-i18n="channels_add">接入通道</span>
                                </button>
                            </div>
                            <div id="channels-content" class="grid gap-4"></div>
@@ -585,8 +852,8 @@
                        <div class="max-w-4xl mx-auto">
                            <div class="flex items-center justify-between mb-6">
                                <div>
-                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="tasks_title">Scheduled Tasks</h2>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="tasks_desc">View and manage scheduled tasks</p>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="tasks_title">定时任务</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="tasks_desc">查看和管理定时任务</p>
                                </div>
                            </div>
                            <div id="tasks-empty" class="flex flex-col items-center justify-center py-20">
@@ -608,8 +875,8 @@
                        <div class="max-w-5xl mx-auto">
                            <div class="flex items-center justify-between mb-6">
                                <div>
-                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="logs_title">Logs</h2>
-                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="logs_desc">Real-time log output (run.log)</p>
+                                    <h2 class="text-xl font-bold text-slate-800 dark:text-slate-100" data-i18n="logs_title">日志</h2>
+                                    <p class="text-sm text-slate-500 dark:text-slate-400 mt-1" data-i18n="logs_desc">实时日志输出 (run.log)</p>
                                </div>
                            </div>
                            <!-- Log Terminal -->
@@ -624,11 +891,11 @@
                                    <div class="flex-1"></div>
                                    <div class="flex items-center gap-1.5">
                                        <span class="w-2 h-2 rounded-full bg-emerald-500 animate-pulse"></span>
-                                        <span class="text-xs text-slate-500" data-i18n="logs_live">Live</span>
+                                        <span class="text-xs text-slate-500" data-i18n="logs_live">实时</span>
                                    </div>
                                </div>
                                <div id="log-output" class="p-4 overflow-y-auto font-mono text-xs leading-relaxed text-slate-300 whitespace-pre-wrap break-all" style="height: calc(100vh - 272px)">
-                                    <p class="text-slate-500" data-i18n="logs_coming_msg">Log streaming will be available here. Connects to run.log for real-time output similar to tail -f.</p>
+                                    <p class="text-slate-500" data-i18n="logs_coming_msg">日志流即将在此提供。将连接 run.log 实现类似 tail -f 的实时输出。</p>
                                </div>
                            </div>
                        </div>
@@ -665,6 +932,7 @@
        </div>
    </div>

+    <script src="https://cdn.jsdelivr.net/npm/d3@7/dist/d3.min.js"></script>
    <script src="assets/js/console.js"></script>
 </body>
 </html>
--- a/channel/web/static/css/console.css
+++ b/channel/web/static/css/console.css
@@ -17,6 +17,45 @@
 .dark ::-webkit-scrollbar-thumb { background: #475569; }
 .dark ::-webkit-scrollbar-thumb:hover { background: #64748b; }

+/* Generic Tooltip (via data-tooltip attribute) */
+[data-tooltip] {
+    position: relative;
+}
+[data-tooltip]::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    left: 50%;
+    bottom: calc(100% + 8px);
+    transform: translateX(-50%);
+    padding: 5px 10px;
+    border-radius: 6px;
+    font-size: 12px;
+    font-weight: 400;
+    line-height: 1.4;
+    white-space: nowrap;
+    background: #1e293b;
+    color: #e2e8f0;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.15s ease;
+    z-index: 100;
+}
+[data-tooltip-pos="bottom"]::after {
+    bottom: auto;
+    top: calc(100% + 8px);
+}
+.dark [data-tooltip]::after {
+    background: #334155;
+    color: #f1f5f9;
+}
+[data-tooltip]:hover::after {
+    opacity: 1;
+}
+[data-tooltip=""]:hover::after {
+    display: none;
+}
+
 /* Sidebar */
 .sidebar-item.active {
    background: rgba(255, 255, 255, 0.08);
@@ -24,9 +63,300 @@
 }
 .sidebar-item.active .item-icon { color: #4ABE6E; }

+/* Session Panel */
+.session-panel {
+    width: 220px;
+    flex-shrink: 0;
+    display: flex;
+    flex-direction: column;
+    background: #fafafa;
+    border-right: 1px solid #e5e7eb;
+    height: 100vh;
+    overflow: hidden;
+    transition: width 0.2s ease;
+}
+.dark .session-panel {
+    background: #111111;
+    border-right-color: rgba(255, 255, 255, 0.08);
+}
+.session-panel.hidden { display: none; }
+.session-panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 12px 16px;
+    border-bottom: 1px solid #e5e7eb;
+    flex-shrink: 0;
+}
+.dark .session-panel-header { border-bottom-color: rgba(255, 255, 255, 0.08); }
+.session-panel-title {
+    font-size: 14px;
+    font-weight: 600;
+    color: #374151;
+}
+.dark .session-panel-title { color: #d1d5db; }
+.session-panel-close {
+    width: 28px;
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 6px;
+    border: none;
+    background: none;
+    color: #9ca3af;
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s;
+    font-size: 12px;
+}
+.session-panel-close:hover {
+    background: #f3f4f6;
+    color: #374151;
+}
+.dark .session-panel-close:hover {
+    background: rgba(255, 255, 255, 0.08);
+    color: #e5e5e5;
+}
+.session-panel-new {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin: 10px 12px;
+    padding: 8px 14px;
+    border-radius: 8px;
+    border: 1px dashed #d1d5db;
+    background: none;
+    color: #6b7280;
+    font-size: 13px;
+    cursor: pointer;
+    transition: border-color 0.15s, color 0.15s, background 0.15s;
+    flex-shrink: 0;
+}
+.session-panel-new:hover {
+    border-color: #9ca3af;
+    color: #374151;
+    background: #f9fafb;
+}
+.dark .session-panel-new {
+    border-color: rgba(255, 255, 255, 0.12);
+    color: #9ca3af;
+}
+.dark .session-panel-new:hover {
+    border-color: rgba(255, 255, 255, 0.25);
+    color: #e5e5e5;
+    background: rgba(255, 255, 255, 0.04);
+}
+
+/* Session List */
+.session-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 4px 8px;
+    scrollbar-width: none;
+}
+.session-list:hover { scrollbar-width: thin; }
+.session-list::-webkit-scrollbar { width: 4px; background: transparent; }
+.session-list::-webkit-scrollbar-thumb { background: transparent; border-radius: 2px; }
+.session-list:hover::-webkit-scrollbar-thumb { background: rgba(0,0,0,0.2); }
+.dark .session-list:hover::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.15); }
+.session-group-label {
+    padding: 10px 8px 4px;
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: #9ca3af;
+}
+.dark .session-group-label { color: #525252; }
+.session-empty {
+    padding: 20px 12px;
+    text-align: center;
+    font-size: 13px;
+    color: #9ca3af;
+}
+.session-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 10px;
+    margin: 1px 0;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s;
+    color: #6b7280;
+    font-size: 13px;
+    position: relative;
+}
+.dark .session-item { color: #a3a3a3; }
+.session-item:hover {
+    background: #f3f4f6;
+    color: #111827;
+}
+.dark .session-item:hover {
+    background: rgba(255, 255, 255, 0.05);
+    color: #e5e5e5;
+}
+.session-item.active {
+    background: #e5e7eb;
+    color: #111827;
+}
+.dark .session-item.active {
+    background: rgba(255, 255, 255, 0.1);
+    color: #ffffff;
+}
+.session-icon {
+    flex-shrink: 0;
+    font-size: 11px;
+    color: #9ca3af;
+    width: 16px;
+    text-align: center;
+}
+.dark .session-icon { color: #525252; }
+.session-item.active .session-icon { color: #4ABE6E; }
+.session-title {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.session-delete {
+    flex-shrink: 0;
+    width: 22px;
+    height: 22px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 5px;
+    font-size: 10px;
+    color: #9ca3af;
+    opacity: 0;
+    transition: opacity 0.15s, color 0.15s, background 0.15s;
+    cursor: pointer;
+    background: none;
+    border: none;
+    padding: 0;
+}
+.session-item:hover .session-delete { opacity: 1; }
+.session-delete:hover {
+    color: #ef4444;
+    background: rgba(239, 68, 68, 0.1);
+}
+.dark .session-delete:hover { background: rgba(239, 68, 68, 0.15); }
+
+/* Context Divider */
+.context-divider {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 24px;
+    color: #9ca3af;
+}
+.context-divider::before, .context-divider::after {
+    content: '';
+    flex: 1;
+    height: 1px;
+    background: linear-gradient(to right, transparent, #d1d5db, transparent);
+}
+.dark .context-divider::before, .dark .context-divider::after {
+    background: linear-gradient(to right, transparent, rgba(255,255,255,0.12), transparent);
+}
+.context-divider span {
+    font-size: 12px;
+    white-space: nowrap;
+    color: #9ca3af;
+}
+
+/* Confirm Modal */
+.confirm-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: 9999;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: rgba(0, 0, 0, 0.4);
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+.confirm-overlay.visible { opacity: 1; }
+.confirm-modal {
+    background: #fff;
+    border-radius: 14px;
+    width: 380px;
+    max-width: 90vw;
+    padding: 28px 24px 20px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.18);
+    transform: scale(0.92);
+    transition: transform 0.2s ease;
+}
+.confirm-overlay.visible .confirm-modal { transform: scale(1); }
+.dark .confirm-modal {
+    background: #1e1e1e;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+}
+.confirm-title {
+    font-size: 16px;
+    font-weight: 600;
+    color: #1f2937;
+    margin-bottom: 8px;
+}
+.dark .confirm-title { color: #e5e7eb; }
+.confirm-message {
+    font-size: 14px;
+    color: #6b7280;
+    line-height: 1.5;
+    margin-bottom: 24px;
+}
+.dark .confirm-message { color: #9ca3af; }
+.confirm-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 10px;
+}
+.confirm-btn {
+    padding: 8px 20px;
+    border-radius: 8px;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    border: none;
+    transition: all 0.15s ease;
+}
+.confirm-btn-cancel {
+    background: #f3f4f6;
+    color: #374151;
+}
+.confirm-btn-cancel:hover { background: #e5e7eb; }
+.dark .confirm-btn-cancel {
+    background: rgba(255, 255, 255, 0.08);
+    color: #d1d5db;
+}
+.dark .confirm-btn-cancel:hover { background: rgba(255, 255, 255, 0.14); }
+.confirm-btn-ok {
+    background: #ef4444;
+    color: #fff;
+}
+.confirm-btn-ok:hover { background: #dc2626; }
+
+/* Mobile: session panel as overlay */
+@media (max-width: 768px) {
+    .session-panel {
+        position: fixed;
+        top: 0;
+        left: 0;
+        z-index: 45;
+        width: 220px;
+        box-shadow: 4px 0 24px rgba(0, 0, 0, 0.15);
+    }
+    .dark .session-panel {
+        box-shadow: 4px 0 24px rgba(0, 0, 0, 0.4);
+    }
+}
+
 /* Menu Groups */
 .menu-group-items { max-height: 0; overflow: hidden; transition: max-height 0.25s ease-out; }
-.menu-group.open .menu-group-items { max-height: 500px; transition: max-height 0.35s ease-in; }
+.menu-group.open .menu-group-items { max-height: 2000px; transition: max-height 0.35s ease-in; }
 .menu-group .chevron { transition: transform 0.25s ease; }
 .menu-group.open .chevron { transform: rotate(90deg); }

@@ -45,7 +375,8 @@
 .msg-content h1 { font-size: 1.4em; }
 .msg-content h2 { font-size: 1.25em; }
 .msg-content h3 { font-size: 1.1em; }
-.msg-content ul, .msg-content ol { margin: 0.5em 0; padding-left: 1.8em; }
+.msg-content ul { margin: 0.5em 0; padding-left: 1.8em; list-style: disc; }
+.msg-content ol { margin: 0.5em 0; padding-left: 1.8em; list-style: decimal; }
 .msg-content li { margin: 0.25em 0; }
 .msg-content pre {
    border-radius: 8px; overflow-x: auto; margin: 0.8em 0;
@@ -124,9 +455,8 @@
    cursor: pointer;
    user-select: none;
 }
-.agent-thinking-step .thinking-header.no-toggle { cursor: default; }
-.agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #64748b; }
-.dark .agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #cbd5e1; }
+.agent-thinking-step .thinking-header:hover { color: #64748b; }
+.dark .agent-thinking-step .thinking-header:hover { color: #cbd5e1; }
 .agent-thinking-step .thinking-header i:first-child { font-size: 0.625rem; margin-top: 1px; }
 .agent-thinking-step .thinking-chevron {
    font-size: 0.5rem;
@@ -146,7 +476,7 @@
    font-size: 0.75rem;
    line-height: 1.5;
    color: #94a3b8;
-    max-height: 200px;
+    max-height: 300px;
    overflow-y: auto;
 }
 .dark .agent-thinking-step .thinking-full {
@@ -157,6 +487,25 @@
 .agent-thinking-step .thinking-full p { margin: 0.25em 0; }
 .agent-thinking-step .thinking-full p:first-child { margin-top: 0; }
 .agent-thinking-step .thinking-full p:last-child { margin-bottom: 0; }
+.agent-thinking-step .thinking-duration {
+    font-size: 0.625rem;
+    color: #b0b8c4;
+    margin-bottom: 0.375rem;
+}
+
+/* Content step - real text output frozen before tool calls */
+.agent-content-step {
+    font-size: 0.875rem;
+    line-height: 1.6;
+    color: inherit;
+    margin-bottom: 0.5rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px dashed rgba(0, 0, 0, 0.06);
+}
+.dark .agent-content-step { border-bottom-color: rgba(255, 255, 255, 0.06); }
+.agent-content-step .agent-content-body p { margin: 0.25em 0; }
+.agent-content-step .agent-content-body p:first-child { margin-top: 0; }
+.agent-content-step .agent-content-body p:last-child { margin-bottom: 0; }

 /* Tool step - collapsible */
 .agent-tool-step .tool-header {
@@ -535,3 +884,195 @@
 .dark .slash-menu-item .desc {
    color: #64748b;
 }
+
+/* ============================================================
+   Knowledge View
+   ============================================================ */
+
+/* Tab toggle */
+.knowledge-tab, .memory-tab {
+    color: #64748b;
+}
+.knowledge-tab.active, .memory-tab.active {
+    background: #fff;
+    color: #334155;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.08);
+}
+.dark .knowledge-tab.active, .dark .memory-tab.active {
+    background: rgba(255,255,255,0.1);
+    color: #e2e8f0;
+}
+
+/* File tree */
+.knowledge-tree-group {
+    margin-bottom: 2px;
+}
+.knowledge-tree-group-btn {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    width: 100%;
+    padding: 6px 8px;
+    border-radius: 6px;
+    font-size: 12px;
+    font-weight: 600;
+    color: #64748b;
+    cursor: pointer;
+    border: none;
+    background: none;
+    transition: background 0.15s, color 0.15s;
+    text-transform: capitalize;
+}
+.knowledge-tree-group-btn:hover {
+    background: rgba(0,0,0,0.04);
+    color: #334155;
+}
+.dark .knowledge-tree-group-btn:hover {
+    background: rgba(255,255,255,0.06);
+    color: #e2e8f0;
+}
+.knowledge-tree-group-btn i.chevron {
+    font-size: 8px;
+    transition: transform 0.15s;
+}
+.knowledge-tree-group.open .chevron {
+    transform: rotate(90deg);
+}
+.knowledge-tree-group-items {
+    display: none;
+}
+.knowledge-tree-group.open .knowledge-tree-group-items {
+    display: block;
+}
+
+.knowledge-tree-file {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 5px 8px 5px 24px;
+    border-radius: 6px;
+    font-size: 12px;
+    color: #64748b;
+    cursor: pointer;
+    border: none;
+    background: none;
+    width: 100%;
+    text-align: left;
+    transition: background 0.15s, color 0.15s;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.knowledge-tree-file:hover {
+    background: rgba(0,0,0,0.04);
+    color: #334155;
+}
+.knowledge-tree-file.active {
+    background: #EDFDF3;
+    color: #228547;
+}
+.dark .knowledge-tree-file:hover {
+    background: rgba(255,255,255,0.06);
+    color: #e2e8f0;
+}
+.dark .knowledge-tree-file.active {
+    background: rgba(74, 190, 110, 0.1);
+    color: #4ABE6E;
+}
+
+/* Graph legend */
+.knowledge-graph-legend {
+    position: absolute;
+    top: 12px;
+    right: 12px;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    font-size: 11px;
+    color: #64748b;
+    z-index: 10;
+}
+.knowledge-graph-legend-item {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+.knowledge-graph-legend-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+}
+
+/* Graph tooltip */
+.knowledge-graph-tooltip {
+    position: absolute;
+    padding: 6px 10px;
+    background: #fff;
+    border: 1px solid #e2e8f0;
+    border-radius: 8px;
+    font-size: 12px;
+    color: #334155;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 0.15s;
+    z-index: 20;
+}
+.dark .knowledge-graph-tooltip {
+    background: #1A1A1A;
+    border-color: rgba(255,255,255,0.1);
+    color: #e2e8f0;
+}
+
+/* Config field tooltip */
+.cfg-tip {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    color: #94a3b8;
+    cursor: help;
+    font-size: 12px;
+}
+.cfg-tip:hover { color: #64748b; }
+.dark .cfg-tip:hover { color: #cbd5e1; }
+.cfg-tip::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    left: 50%;
+    bottom: calc(100% + 6px);
+    transform: translateX(-50%);
+    padding: 6px 10px;
+    border-radius: 8px;
+    font-size: 12px;
+    font-weight: 400;
+    line-height: 1.4;
+    white-space: nowrap;
+    background: #1e293b;
+    color: #e2e8f0;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.15s;
+    z-index: 50;
+}
+.dark .cfg-tip::after {
+    background: #334155;
+    color: #f1f5f9;
+}
+.cfg-tip:hover::after {
+    opacity: 1;
+}
+
+/* Example cards: equal height via flex stretch + fixed 2-line description area */
+.example-card {
+    display: flex;
+    flex-direction: column;
+}
+.example-card > p {
+    flex: 1;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+    min-height: 2.5em;  /* ~2 lines at text-sm leading-relaxed */
+}
--- a/channel/web/static/js/console.js
+++ b/channel/web/static/js/console.js
--- a/channel/web/web_channel.py
+++ b/channel/web/web_channel.py
@@ -1,3 +1,5 @@
+import hashlib
+import hmac
 import time
 import json
 import logging
@@ -23,6 +25,62 @@ from config import conf
 IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"}
 VIDEO_EXTENSIONS = {".mp4", ".webm", ".avi", ".mov", ".mkv"}

+def _is_password_enabled():
+    return bool(conf().get("web_password", ""))
+
+
+def _session_expire_seconds():
+    return int(conf().get("web_session_expire_days", 30)) * 86400
+
+
+def _create_auth_token():
+    """Create a stateless signed token: ``<timestamp_hex>.<hmac_hex>``."""
+    ts = format(int(time.time()), "x")
+    sig = hmac.new(
+        conf().get("web_password", "").encode(),
+        ts.encode(),
+        hashlib.sha256,
+    ).hexdigest()
+    return f"{ts}.{sig}"
+
+
+def _verify_auth_token(token):
+    """Verify a signed token is valid and not expired.
+
+    The token is derived from the password, so it survives server restarts
+    and automatically invalidates when the password changes.
+    """
+    if not token or "." not in token:
+        return False
+    ts_hex, sig = token.split(".", 1)
+    try:
+        ts = int(ts_hex, 16)
+    except ValueError:
+        return False
+    if time.time() - ts > _session_expire_seconds():
+        return False
+    expected = hmac.new(
+        conf().get("web_password", "").encode(),
+        ts_hex.encode(),
+        hashlib.sha256,
+    ).hexdigest()
+    return hmac.compare_digest(sig, expected)
+
+
+def _check_auth():
+    """Return True if request is authenticated or password not enabled."""
+    if not _is_password_enabled():
+        return True
+    return _verify_auth_token(web.cookies().get("cow_auth_token", ""))
+
+
+def _require_auth():
+    """Raise 401 if not authenticated. Call at the top of protected handlers."""
+    if not _check_auth():
+        raise web.HTTPError("401 Unauthorized",
+                            {"Content-Type": "application/json; charset=utf-8"},
+                            json.dumps({"status": "error", "message": "Unauthorized"}))
+

 def _get_upload_dir() -> str:
    from common.utils import expand_path
@@ -32,6 +90,42 @@ def _get_upload_dir() -> str:
    return tmp_dir


+def _generate_session_title(user_message: str, assistant_reply: str = "") -> str:
+    """
+    Generate a short session title by calling the current bot's reply_text.
+    """
+    import re
+    fallback = user_message[:50].split("\n")[0].strip() or "New Chat"
+    try:
+        from bridge.bridge import Bridge
+        from models.session_manager import Session
+        bot = Bridge().get_bot("chat")
+
+        prompt_parts = [f"User: {user_message[:300]}"]
+        if assistant_reply:
+            prompt_parts.append(f"Assistant: {assistant_reply[:300]}")
+
+        session = Session("__title_gen__", system_prompt="")
+        session.messages = [
+            {"role": "user", "content": (
+                "Generate a very short title (max 15 characters for Chinese, max 6 words for English) "
+                "summarizing this conversation. Return ONLY the title text, nothing else.\n\n"
+                + "\n".join(prompt_parts)
+            )}
+        ]
+
+        result = bot.reply_text(session)
+        raw = (result.get("content") or "").strip()
+        # Strip <think>...</think> reasoning blocks
+        title = re.sub(r'<think>.*?</think>', '', raw, flags=re.DOTALL).strip().strip('"\'')
+        logger.info(f"[WebChannel] Title generation result: '{title}' (len={len(title)})")
+        if title and len(title) <= 50:
+            return title
+    except Exception as e:
+        logger.warning(f"[WebChannel] Title generation failed: {e}")
+    return fallback
+
+
 class WebMessage(ChatMessage):
    def __init__(
            self,
@@ -96,9 +190,43 @@ 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
+
+                # Skip http-URL FILE/IMAGE_URL replies produced by chat_channel's media extraction:
+                # the text reply (already sent as "done") contains the URL and the frontend will
+                # render it via renderMarkdown/injectVideoPlayers, so no separate SSE event needed.
+                if reply.type in (ReplyType.FILE, ReplyType.IMAGE_URL) and content.startswith(("http://", "https://")):
+                    logger.debug(f"SSE skipped http media reply for request {request_id}")
+                    return
+
                self.sse_queues[request_id].put({
                    "type": "done",
                    "content": content,
@@ -134,7 +262,12 @@ class WebChannel(ChatChannel):
            event_type = event.get("type")
            data = event.get("data", {})

-            if event_type == "message_update":
+            if event_type == "reasoning_update":
+                delta = data.get("delta", "")
+                if delta:
+                    q.put({"type": "reasoning", "content": delta})
+
+            elif event_type == "message_update":
                delta = data.get("delta", "")
                if delta:
                    q.put({"type": "delta", "content": delta})
@@ -161,6 +294,24 @@ class WebChannel(ChatChannel):
                    "execution_time": round(exec_time, 2)
                })

+            elif event_type == "message_end":
+                tool_calls = data.get("tool_calls", [])
+                if tool_calls:
+                    q.put({"type": "message_end", "has_tool_calls": True})
+
+            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):
@@ -282,14 +433,18 @@ class WebChannel(ChatChannel):
        """
        SSE generator for a given request_id.
        Yields UTF-8 encoded bytes to avoid WSGI Latin-1 mangling.
+        Supports client reconnection: the queue is only removed after a
+        "done" event is consumed, so a new GET /stream with the same
+        request_id can resume reading remaining events.
        """
        if request_id not in self.sse_queues:
            yield b"data: {\"type\": \"error\", \"message\": \"invalid request_id\"}\n\n"
            return

        q = self.sse_queues[request_id]
-        timeout = 300  # 5 minutes max
-        deadline = time.time() + timeout
+        idle_timeout = 600  # 10 minutes without any real event
+        deadline = time.time() + idle_timeout
+        done = False

        try:
            while time.time() < deadline:
@@ -299,13 +454,18 @@ class WebChannel(ChatChannel):
                    yield b": keepalive\n\n"
                    continue

+                # Real event received, reset idle deadline
+                deadline = time.time() + idle_timeout
+
                payload = json.dumps(item, ensure_ascii=False)
                yield f"data: {payload}\n\n".encode("utf-8")

                if item.get("type") == "done":
+                    done = True
                    break
        finally:
-            self.sse_queues.pop(request_id, None)
+            if done:
+                self.sse_queues.pop(request_id, None)

    def poll_response(self):
        """
@@ -374,9 +534,13 @@ class WebChannel(ChatChannel):

        urls = (
            '/', 'RootHandler',
+            '/auth/login', 'AuthLoginHandler',
+            '/auth/check', 'AuthCheckHandler',
+            '/auth/logout', 'AuthLogoutHandler',
            '/message', 'MessageHandler',
            '/upload', 'UploadHandler',
            '/uploads/(.*)', 'UploadsHandler',
+            '/api/file', 'FileServeHandler',
            '/poll', 'PollHandler',
            '/stream', 'StreamHandler',
            '/chat', 'ChatHandler',
@@ -387,7 +551,14 @@ class WebChannel(ChatChannel):
            '/api/skills', 'SkillsHandler',
            '/api/memory', 'MemoryHandler',
            '/api/memory/content', 'MemoryContentHandler',
+            '/api/knowledge/list', 'KnowledgeListHandler',
+            '/api/knowledge/read', 'KnowledgeReadHandler',
+            '/api/knowledge/graph', 'KnowledgeGraphHandler',
            '/api/scheduler', 'SchedulerHandler',
+            '/api/sessions', 'SessionsHandler',
+            '/api/sessions/(.*)/generate_title', 'SessionTitleHandler',
+            '/api/sessions/(.*)/clear_context', 'SessionClearContextHandler',
+            '/api/sessions/(.*)', 'SessionDetailHandler',
            '/api/history', 'HistoryHandler',
            '/api/logs', 'LogsHandler',
            '/api/version', 'VersionHandler',
@@ -406,8 +577,14 @@ class WebChannel(ChatChannel):
        func = web.httpserver.StaticMiddleware(app.wsgifunc())
        func = web.httpserver.LogMiddleware(func)
        server = web.httpserver.WSGIServer(("0.0.0.0", port), func)
-        # Allow concurrent requests by not blocking on in-flight handler threads
        server.daemon_threads = True
+        # Default request_queue_size(5) / timeout(10s) / numthreads(10) are
+        # too small: when SSE streams occupy many threads, the backlog fills
+        # and new connections get refused (ERR_CONNECTION_ABORTED).
+        server.request_queue_size = 128
+        server.timeout = 300
+        server.requests.min = 20
+        server.requests.max = 80
        self._http_server = server
        try:
            server.start()
@@ -426,24 +603,62 @@ class WebChannel(ChatChannel):

 class RootHandler:
    def GET(self):
-        # 重定向到/chat
        raise web.seeother('/chat')


+class AuthCheckHandler:
+    def GET(self):
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        if not _is_password_enabled():
+            return json.dumps({"status": "success", "auth_required": False})
+        if _check_auth():
+            return json.dumps({"status": "success", "auth_required": True, "authenticated": True})
+        return json.dumps({"status": "success", "auth_required": True, "authenticated": False})
+
+
+class AuthLoginHandler:
+    def POST(self):
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        if not _is_password_enabled():
+            return json.dumps({"status": "success"})
+        try:
+            data = json.loads(web.data())
+        except Exception:
+            return json.dumps({"status": "error", "message": "Invalid request"})
+        password = data.get("password", "")
+        expected = conf().get("web_password", "")
+        if not hmac.compare_digest(password, expected):
+            logger.warning("[WebChannel] Invalid login attempt")
+            return json.dumps({"status": "error", "message": "Wrong password"})
+        token = _create_auth_token()
+        web.setcookie("cow_auth_token", token, expires=_session_expire_seconds(),
+                       path="/", httponly=True, samesite="Lax")
+        return json.dumps({"status": "success"})
+
+
+class AuthLogoutHandler:
+    def POST(self):
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        web.setcookie("cow_auth_token", "", expires=-1, path="/")
+        return json.dumps({"status": "success"})
+
+
 class MessageHandler:
    def POST(self):
+        _require_auth()
        return WebChannel().post_message()


 class UploadHandler:
    def POST(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        return WebChannel().upload_file()


 class UploadsHandler:
    def GET(self, file_name):
-        """Serve uploaded files from workspace/tmp/ for preview."""
+        _require_auth()
        try:
            upload_dir = _get_upload_dir()
            full_path = os.path.normpath(os.path.join(upload_dir, file_name))
@@ -463,13 +678,41 @@ class UploadsHandler:
            raise web.notfound()


+class FileServeHandler:
+    def GET(self):
+        _require_auth()
+        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):
+        _require_auth()
        return WebChannel().poll_response()


 class StreamHandler:
    def GET(self):
+        _require_auth()
        params = web.input(request_id='')
        request_id = params.request_id
        if not request_id:
@@ -485,10 +728,15 @@ class StreamHandler:

 class ChatHandler:
    def GET(self):
-        # 正常返回聊天页面
+        web.header('Cache-Control', 'no-cache, no-store, must-revalidate')
+        web.header('Pragma', 'no-cache')
        file_path = os.path.join(os.path.dirname(__file__), 'chat.html')
        with open(file_path, 'r', encoding='utf-8') as f:
-            return f.read()
+            html = f.read()
+        cache_bust = str(int(time.time()))
+        html = html.replace('assets/js/console.js', f'assets/js/console.js?v={cache_bust}')
+        html = html.replace('assets/css/console.css', f'assets/css/console.css?v={cache_bust}')
+        return html


 class ConfigHandler:
@@ -496,7 +744,7 @@ class ConfigHandler:
    _RECOMMENDED_MODELS = [
        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.QWEN36_PLUS, const.QWEN35_PLUS, const.QWEN3_MAX,
        const.KIMI_K2_5, const.KIMI_K2,
        const.DOUBAO_SEED_2_PRO, const.DOUBAO_SEED_2_CODE,
        const.CLAUDE_4_6_SONNET, const.CLAUDE_4_6_OPUS, const.CLAUDE_4_5_SONNET,
@@ -511,7 +759,7 @@ class ConfigHandler:
            "api_key_field": "minimax_api_key",
            "api_base_key": None,
            "api_base_default": None,
-            "models": [const.MINIMAX_M2_7, const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING],
+            "models": [const.MINIMAX_M2_7, const.MINIMAX_M2_7_HIGHSPEED, const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING],
        }),
        ("zhipu", {
            "label": "智谱AI",
@@ -525,7 +773,7 @@ class ConfigHandler:
            "api_key_field": "dashscope_api_key",
            "api_base_key": None,
            "api_base_default": None,
-            "models": [const.QWEN3_MAX, const.QWEN35_PLUS],
+            "models": [const.QWEN36_PLUS, const.QWEN35_PLUS, const.QWEN3_MAX],
        }),
        ("moonshot", {
            "label": "Kimi",
@@ -569,6 +817,13 @@ class ConfigHandler:
            "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.QWEN3_5_27B, const.QWEN3_235B_A22B_INSTRUCT_2507],
+        }),
        ("linkai", {
            "label": "LinkAI",
            "api_key_field": "linkai_api_key",
@@ -586,6 +841,7 @@ class ConfigHandler:
        "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",
+        "enable_thinking", "web_password",
    }

    @staticmethod
@@ -596,7 +852,7 @@ class ConfigHandler:
        return value[:4] + "*" * (len(value) - 8) + value[-4:]

    def GET(self):
-        """Return configuration info and provider/model metadata."""
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            local_config = conf()
@@ -624,6 +880,9 @@ class ConfigHandler:
                    "api_key_field": p.get("api_key_field"),
                }

+            raw_pwd = local_config.get("web_password", "")
+            masked_pwd = ("*" * len(raw_pwd)) if raw_pwd else ""
+
            return json.dumps({
                "status": "success",
                "use_agent": use_agent,
@@ -634,17 +893,19 @@ class ConfigHandler:
                "channel_type": local_config.get("channel_type", ""),
                "agent_max_context_tokens": local_config.get("agent_max_context_tokens", 50000),
                "agent_max_context_turns": local_config.get("agent_max_context_turns", 20),
-                "agent_max_steps": local_config.get("agent_max_steps", 15),
+                "agent_max_steps": local_config.get("agent_max_steps", 20),
+                "enable_thinking": bool(local_config.get("enable_thinking", True)),
                "api_bases": api_bases,
                "api_keys": api_keys_masked,
                "providers": providers,
+                "web_password_masked": masked_pwd,
            }, ensure_ascii=False)
        except Exception as e:
            logger.error(f"Error getting config: {e}")
            return json.dumps({"status": "error", "message": str(e)})

    def POST(self):
-        """Update configuration values in memory and persist to config.json."""
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            data = json.loads(web.data())
@@ -659,7 +920,7 @@ class ConfigHandler:
                    continue
                if key in ("agent_max_context_tokens", "agent_max_context_turns", "agent_max_steps"):
                    value = int(value)
-                if key == "use_linkai":
+                if key in ("use_linkai", "enable_thinking"):
                    value = bool(value)
                local_config[key] = value
                applied[key] = value
@@ -793,6 +1054,7 @@ class ChannelsHandler:
        return set(cls._parse_channel_list(conf().get("channel_type", "")))

    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            local_config = conf()
@@ -830,6 +1092,7 @@ class ChannelsHandler:
            return json.dumps({"status": "error", "message": str(e)})

    def POST(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            body = json.loads(web.data())
@@ -1083,6 +1346,7 @@ class WeixinQrHandler:
        return None

    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            running_ch = self._get_running_channel()
@@ -1115,6 +1379,7 @@ class WeixinQrHandler:
            return json.dumps({"status": "error", "message": str(e)})

    def POST(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            body = json.loads(web.data())
@@ -1202,6 +1467,7 @@ def _get_workspace_root():

 class ToolsHandler:
    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.tools.tool_manager import ToolManager
@@ -1226,6 +1492,7 @@ class ToolsHandler:

 class SkillsHandler:
    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.skills.service import SkillService
@@ -1240,6 +1507,7 @@ class SkillsHandler:
            return json.dumps({"status": "error", "message": str(e)})

    def POST(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.skills.service import SkillService
@@ -1266,13 +1534,17 @@ class SkillsHandler:

 class MemoryHandler:
    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.memory.service import MemoryService
-            params = web.input(page='1', page_size='20')
+            params = web.input(page='1', page_size='20', category='memory')
            workspace_root = _get_workspace_root()
            service = MemoryService(workspace_root)
-            result = service.list_files(page=int(params.page), page_size=int(params.page_size))
+            result = service.list_files(
+                page=int(params.page), page_size=int(params.page_size),
+                category=params.category,
+            )
            return json.dumps({"status": "success", **result}, ensure_ascii=False)
        except Exception as e:
            logger.error(f"[WebChannel] Memory API error: {e}")
@@ -1281,16 +1553,19 @@ class MemoryHandler:

 class MemoryContentHandler:
    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.memory.service import MemoryService
-            params = web.input(filename='')
+            params = web.input(filename='', category='memory')
            if not params.filename:
                return json.dumps({"status": "error", "message": "filename required"})
            workspace_root = _get_workspace_root()
            service = MemoryService(workspace_root)
-            result = service.get_content(params.filename)
+            result = service.get_content(params.filename, category=params.category)
            return json.dumps({"status": "success", **result}, ensure_ascii=False)
+        except ValueError:
+            return json.dumps({"status": "error", "message": "invalid filename"})
        except FileNotFoundError:
            return json.dumps({"status": "error", "message": "file not found"})
        except Exception as e:
@@ -1300,6 +1575,7 @@ class MemoryContentHandler:

 class SchedulerHandler:
    def GET(self):
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        try:
            from agent.tools.scheduler.task_store import TaskStore
@@ -1313,16 +1589,138 @@ class SchedulerHandler:
            return json.dumps({"status": "error", "message": str(e)})


+class SessionsHandler:
+    def GET(self):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            params = web.input(page='1', page_size='50')
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            result = store.list_sessions(
+                channel_type="web",
+                page=int(params.page),
+                page_size=int(params.page_size),
+            )
+            return json.dumps({"status": "success", **result}, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"[WebChannel] Sessions API error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
+class SessionDetailHandler:
+    def DELETE(self, session_id: str):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        logger.info(f"[WebChannel] DELETE session request: {session_id}")
+        try:
+            if not session_id:
+                return json.dumps({"status": "error", "message": "session_id required"})
+
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            store.clear_session(session_id)
+
+            # Also remove the Agent instance from AgentBridge if exists
+            try:
+                from bridge.bridge import Bridge
+                ab = Bridge().get_agent_bridge()
+                if session_id in ab.agents:
+                    del ab.agents[session_id]
+                    logger.info(f"[WebChannel] Removed agent instance for session {session_id}")
+            except Exception:
+                pass
+
+            channel = WebChannel()
+            channel.session_queues.pop(session_id, None)
+
+            logger.info(f"[WebChannel] Session deleted: {session_id}")
+            return json.dumps({"status": "success"})
+        except Exception as e:
+            logger.error(f"[WebChannel] Session delete error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+    def PUT(self, session_id: str):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            if not session_id:
+                return json.dumps({"status": "error", "message": "session_id required"})
+            body = json.loads(web.data())
+            title = body.get("title", "").strip()
+            if not title:
+                return json.dumps({"status": "error", "message": "title required"})
+
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            found = store.rename_session(session_id, title)
+            if not found:
+                return json.dumps({"status": "error", "message": "session not found"})
+            return json.dumps({"status": "success"})
+        except Exception as e:
+            logger.error(f"[WebChannel] Session rename error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
+class SessionTitleHandler:
+    def POST(self, session_id: str):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            if not session_id:
+                return json.dumps({"status": "error", "message": "session_id required"})
+
+            body = json.loads(web.data())
+            user_message = body.get("user_message", "")
+            assistant_reply = body.get("assistant_reply", "")
+            if not user_message:
+                return json.dumps({"status": "error", "message": "user_message required"})
+
+            title = _generate_session_title(user_message, assistant_reply)
+
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            updated = store.rename_session(session_id, title)
+            logger.info(f"[WebChannel] Session title set: sid={session_id}, title='{title}', db_updated={updated}")
+
+            return json.dumps({"status": "success", "title": title}, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"[WebChannel] Title generation error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
+class SessionClearContextHandler:
+    def POST(self, session_id: str):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            if not session_id:
+                return json.dumps({"status": "error", "message": "session_id required"})
+
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            new_seq = store.clear_context(session_id)
+
+            # Delete the agent instance so a fresh one is created on the next message
+            try:
+                from bridge.bridge import Bridge
+                bridge = Bridge()
+                ab = bridge.get_agent_bridge()
+                if session_id in ab.agents:
+                    del ab.agents[session_id]
+                    logger.info(f"[WebChannel] Cleared agent instance for session {session_id}")
+            except Exception:
+                pass
+
+            return json.dumps({"status": "success", "context_start_seq": new_seq})
+        except Exception as e:
+            logger.error(f"[WebChannel] Clear context error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
 class HistoryHandler:
    def GET(self):
-        """
-        Return paginated conversation history for a session.
-
-        Query params:
-            session_id  (required)
-            page        int, default 1  (1 = most recent messages)
-            page_size   int, default 20
-        """
+        _require_auth()
        web.header('Content-Type', 'application/json; charset=utf-8')
        web.header('Access-Control-Allow-Origin', '*')
        try:
@@ -1346,7 +1744,7 @@ class HistoryHandler:

 class LogsHandler:
    def GET(self):
-        """Stream the last N lines of run.log as SSE, then tail new lines."""
+        _require_auth()
        web.header('Content-Type', 'text/event-stream; charset=utf-8')
        web.header('Cache-Control', 'no-cache')
        web.header('X-Accel-Buffering', 'no')
@@ -1432,6 +1830,50 @@ class AssetsHandler:
            raise web.notfound()


+class KnowledgeListHandler:
+    def GET(self):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            from agent.knowledge.service import KnowledgeService
+            svc = KnowledgeService(_get_workspace_root())
+            result = svc.list_tree()
+            return json.dumps({"status": "success", **result}, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"[WebChannel] Knowledge list error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
+class KnowledgeReadHandler:
+    def GET(self):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            from agent.knowledge.service import KnowledgeService
+            params = web.input(path='')
+            svc = KnowledgeService(_get_workspace_root())
+            result = svc.read_file(params.path)
+            return json.dumps({"status": "success", **result}, ensure_ascii=False)
+        except (ValueError, FileNotFoundError) as e:
+            return json.dumps({"status": "error", "message": str(e)})
+        except Exception as e:
+            logger.error(f"[WebChannel] Knowledge read error: {e}")
+            return json.dumps({"status": "error", "message": str(e)})
+
+
+class KnowledgeGraphHandler:
+    def GET(self):
+        _require_auth()
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        try:
+            from agent.knowledge.service import KnowledgeService
+            svc = KnowledgeService(_get_workspace_root())
+            return json.dumps(svc.build_graph(), ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"[WebChannel] Knowledge graph error: {e}")
+            return json.dumps({"nodes": [], "links": []})
+
+
 class VersionHandler:
    def GET(self):
        web.header('Content-Type', 'application/json; charset=utf-8')
--- a/channel/wecom_bot/wecom_bot_channel.py
+++ b/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"] or content
+                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},
--- a/channel/weixin/weixin_api.py
+++ b/channel/weixin/weixin_api.py
@@ -37,11 +37,19 @@ def _random_wechat_uin() -> str:
    return base64.b64encode(str(val).encode("utf-8")).decode("utf-8")


+CHANNEL_VERSION = "2.0.0"
+# iLink-App-ClientVersion: uint32 encoded as major<<16 | minor<<8 | patch
+# 2.0.0 → 0x00020000 = 131072
+CLIENT_VERSION = "131072"
+
+
 def _build_headers(token: str = "") -> dict:
    headers = {
        "Content-Type": "application/json",
        "AuthorizationType": "ilink_bot_token",
        "X-WECHAT-UIN": _random_wechat_uin(),
+        "iLink-App-Id": "bot",
+        "iLink-App-ClientVersion": CLIENT_VERSION,
    }
    if token:
        headers["Authorization"] = f"Bearer {token}"
@@ -64,6 +72,7 @@ class WeixinApi:
    def _post(self, endpoint: str, body: dict, timeout: int = DEFAULT_API_TIMEOUT) -> dict:
        url = _ensure_trailing_slash(self.base_url) + endpoint
        headers = _build_headers(self.token)
+        body.setdefault("base_info", {}).setdefault("channel_version", CHANNEL_VERSION)
        try:
            resp = requests.post(url, json=body, headers=headers, timeout=timeout)
            resp.raise_for_status()
@@ -210,7 +219,10 @@ class WeixinApi:
    def poll_qr_status(self, qrcode: str, timeout: int = QR_POLL_TIMEOUT) -> dict:
        url = (_ensure_trailing_slash(self.base_url) +
               f"ilink/bot/get_qrcode_status?qrcode={requests.utils.quote(qrcode)}")
-        headers = {"iLink-App-ClientVersion": "1"}
+        headers = {
+            "iLink-App-Id": "bot",
+            "iLink-App-ClientVersion": CLIENT_VERSION,
+        }
        try:
            resp = requests.get(url, headers=headers, timeout=timeout)
            resp.raise_for_status()
@@ -303,13 +315,18 @@ def upload_media_to_cdn(api: WeixinApi, file_path: str, to_user_id: str,
                filesize=cipher_size,
                aeskey=aes_key_hex,
            )
-            upload_param = resp.get("upload_param", "")
-            if not upload_param:
-                raise RuntimeError(f"[Weixin] getUploadUrl returned no upload_param: {resp}")

-            cdn_url = (f"{api.cdn_base_url}/upload"
-                       f"?encrypted_query_param={quote(upload_param)}"
-                       f"&filekey={quote(filekey)}")
+            # 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}")

            cdn_resp = requests.post(cdn_url, data=encrypted, headers={
                "Content-Type": "application/octet-stream",
--- a/channel/weixin/weixin_channel.py
+++ b/channel/weixin/weixin_channel.py
@@ -166,10 +166,18 @@ class WeixinChannel(ChatChannel):
        print("=" * 60)
        try:
            import qrcode as qr_lib
+            import io
            qr = qr_lib.QRCode(error_correction=qr_lib.constants.ERROR_CORRECT_L, box_size=1, border=1)
            qr.add_data(qrcode_url)
            qr.make(fit=True)
-            qr.print_ascii(invert=True)
+            buf = io.StringIO()
+            qr.print_ascii(out=buf, invert=True)
+            try:
+                print(buf.getvalue())
+            except UnicodeEncodeError:
+                # Windows GBK terminals cannot render Unicode block characters
+                print(f"\n  (终端不支持显示二维码，请使用链接扫码)")
+                print(f"  二维码链接: {qrcode_url}\n")
        except ImportError:
            print(f"\n  二维码链接: {qrcode_url}")
            print("  (安装 'qrcode' 包可在终端显示二维码)\n")
--- a/cli/VERSION
+++ b/cli/VERSION
@@ -1 +1 @@
-2.0.4
+2.0.6
--- a/cli/cli.py
+++ b/cli/cli.py
@@ -6,6 +6,7 @@ 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
+from cli.commands.knowledge import knowledge


 HELP_TEXT = """Usage: cow COMMAND [ARGS]...
@@ -22,6 +23,7 @@ Commands:
  status   Show CowAgent running status.
  logs     View CowAgent logs.
  skill    Manage CowAgent skills.
+  knowledge  Manage knowledge base.
  install-browser  Install browser tool (Playwright + Chromium).

 Tip: You can also send /help, /skill list, etc. in agent chat."""
@@ -69,6 +71,7 @@ main.add_command(update)
 main.add_command(status)
 main.add_command(logs)
 main.add_command(context)
+main.add_command(knowledge)
 main.add_command(install_browser)


--- a/cli/commands/install.py
+++ b/cli/commands/install.py
@@ -3,9 +3,25 @@
 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)."""
@@ -13,51 +29,231 @@ def _has_display() -> bool:


 def _is_headless_linux() -> bool:
-    """True when running on a Linux server without a display."""
    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)."""
-    python = sys.executable
-
-    # Step 1: Install playwright package
-    click.echo(click.style("[1/3] Installing playwright Python package...", fg="yellow"))
-    ret = subprocess.call([python, "-m", "pip", "install", "playwright"])
-    if ret != 0:
-        click.echo(click.style("Failed to install playwright package.", fg="red"))
-        raise SystemExit(1)
-    click.echo(click.style("playwright package installed.", fg="green"))
-    click.echo()
-
-    # Step 2: System dependencies (Linux only)
-    if sys.platform == "linux":
-        click.echo(click.style("[2/3] Installing system dependencies (Linux)...", fg="yellow"))
-        ret = subprocess.call([python, "-m", "playwright", "install-deps", "chromium"])
-        if ret != 0:
-            click.echo(click.style(
-                "Could not auto-install system deps (may need sudo).\n"
-                f"  Run manually: sudo {python} -m playwright install-deps chromium",
-                fg="yellow",
-            ))
-    else:
-        click.echo(click.style(f"[2/3] Skipping system deps (not needed on {sys.platform}).", fg="yellow"))
-    click.echo()
-
-    # Step 3: Install Chromium (headless shell on Linux servers, full elsewhere)
-    click.echo(click.style("[3/3] Installing Chromium browser...", fg="yellow"))
-    cmd = [python, "-m", "playwright", "install", "chromium"]
-    if _is_headless_linux():
-        cmd.append("--only-shell")
-        click.echo("  (headless-only mode for Linux server)")
-    elif sys.platform == "linux":
-        click.echo("  (full browser for Linux desktop)")
-
-    ret = subprocess.call(cmd)
-    if ret != 0:
-        click.echo(click.style("Failed to install Chromium.", fg="red"))
-        raise SystemExit(1)
-
-    click.echo()
-    click.echo(click.style("Browser tool ready! Restart CowAgent to enable it.", fg="green"))
+    code = run_install_browser()
+    if code != 0:
+        raise SystemExit(code)
--- a/cli/commands/knowledge.py
+++ b/cli/commands/knowledge.py
@@ -0,0 +1,121 @@
+"""cow knowledge - Knowledge base management commands."""
+
+import os
+
+import click
+
+from cli.utils import get_project_root
+
+
+def _get_knowledge_dir():
+    """Resolve the knowledge directory path from config or default."""
+    try:
+        import sys
+        sys.path.insert(0, get_project_root())
+        from config import conf
+        from common.utils import expand_path
+        workspace = expand_path(conf().get("agent_workspace", "~/cow"))
+    except Exception:
+        workspace = os.path.expanduser("~/cow")
+    return os.path.join(workspace, "knowledge")
+
+
+def _get_knowledge_enabled():
+    try:
+        import sys
+        sys.path.insert(0, get_project_root())
+        from config import conf
+        return conf().get("knowledge", True)
+    except Exception:
+        return True
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def knowledge(ctx):
+    """Manage CowAgent knowledge base."""
+    if ctx.invoked_subcommand is None:
+        click.echo(_stats())
+
+
+@knowledge.command("list")
+def knowledge_list():
+    """Display knowledge base file tree."""
+    click.echo(_tree())
+
+
+def _stats() -> str:
+    knowledge_dir = _get_knowledge_dir()
+    if not os.path.isdir(knowledge_dir):
+        return "Knowledge base directory not found."
+
+    enabled = _get_knowledge_enabled()
+    total_files = 0
+    total_bytes = 0
+    cat_count = {}
+
+    for root, dirs, files in os.walk(knowledge_dir):
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        rel_root = os.path.relpath(root, knowledge_dir)
+        category = rel_root.split(os.sep)[0] if rel_root != "." else "root"
+        for f in files:
+            if f.endswith(".md") and f not in ("index.md", "log.md"):
+                total_files += 1
+                total_bytes += os.path.getsize(os.path.join(root, f))
+                cat_count[category] = cat_count.get(category, 0) + 1
+
+    status_icon = click.style("enabled", fg="green") if enabled else click.style("disabled", fg="red")
+    lines = [
+        f"\n  Knowledge Base  [{status_icon}]",
+        "",
+        f"  Pages:  {total_files}",
+        f"  Size:   {total_bytes / 1024:.1f} KB",
+        "",
+    ]
+    if cat_count:
+        lines.append("  Categories:")
+        for cat in sorted(cat_count.keys()):
+            lines.append(f"    {cat}/  ({cat_count[cat]} pages)")
+        lines.append("")
+
+    lines.append(f"  Path: {knowledge_dir}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _tree() -> str:
+    knowledge_dir = _get_knowledge_dir()
+    if not os.path.isdir(knowledge_dir):
+        return "Knowledge base directory not found."
+
+    tree_lines = ["  knowledge/"]
+
+    subdirs = sorted([
+        d for d in os.listdir(knowledge_dir)
+        if os.path.isdir(os.path.join(knowledge_dir, d)) and not d.startswith(".")
+    ])
+
+    for i, subdir in enumerate(subdirs):
+        is_last_dir = (i == len(subdirs) - 1)
+        branch = "└── " if is_last_dir else "├── "
+        subdir_path = os.path.join(knowledge_dir, subdir)
+        md_files = sorted([
+            f for f in os.listdir(subdir_path)
+            if f.endswith(".md") and not f.startswith(".")
+        ])
+        tree_lines.append(f"  {branch}{subdir}/ ({len(md_files)})")
+
+        child_prefix = "      " if is_last_dir else "  │   "
+        max_show = 15
+        for j, fname in enumerate(md_files[:max_show]):
+            is_last_file = (j == len(md_files[:max_show]) - 1) and len(md_files) <= max_show
+            fb = "└── " if is_last_file else "├── "
+            name = fname.replace(".md", "")
+            tree_lines.append(f"{child_prefix}{fb}{name}")
+        if len(md_files) > max_show:
+            tree_lines.append(f"{child_prefix}└── ... +{len(md_files) - max_show} more")
+
+    if not subdirs:
+        tree_lines.append("  (empty)")
+
+    return "\n" + "\n".join(tree_lines) + "\n"
--- a/cli/commands/process.py
+++ b/cli/commands/process.py
@@ -178,7 +178,10 @@ def update(ctx):
    """Update CowAgent and restart."""
    root = get_project_root()

-    # 1. Git pull while service is still running
+    # 1. Stop service first so git pull won't conflict with running code
+    ctx.invoke(stop)
+
+    # 2. Git pull
    if os.path.isdir(os.path.join(root, ".git")):
        click.echo("Pulling latest code...")
        ret = subprocess.call(["git", "pull"], cwd=root)
@@ -188,28 +191,61 @@ def update(ctx):
    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"],
+
+    if _IS_WIN:
+        # On Windows, `cow.exe` (this process) locks the exe file, so
+        # `pip install -e .` fails with WinError 5.  Write a small .bat
+        # helper that waits for cow.exe to exit, then installs & starts.
+        bat = os.path.join(root, "_cow_update.bat")
+        lines = [
+            "@echo off",
+            "chcp 65001 >nul",
+            "echo Waiting for cow.exe to exit...",
+            "timeout /t 3 /nobreak >nul",
+        ]
+        if os.path.exists(req_file):
+            lines.append(f'echo Installing dependencies...')
+            lines.append(f'"{python}" -m pip install -r requirements.txt -q')
+        lines += [
+            "echo Reinstalling cow CLI...",
+            f'"{python}" -m pip install -e . -q',
+            "echo Starting CowAgent...",
+            f'"{python}" -m cli.cli start --no-logs',
+            "echo.",
+            "echo Update complete. You can close this window.",
+            "pause >nul",
+            "del \"%~f0\"",
+        ]
+        with open(bat, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines) + "\n")
+
+        subprocess.Popen(
+            ["cmd.exe", "/c", "start", "CowAgent Update", "/wait", bat],
+            cwd=root,
+        )
+        click.echo(click.style(
+            "✓ Update script launched. Please follow the new window for progress.",
+            fg="green"))
+    else:
+        # 3. Install dependencies
+        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,
        )
-    click.echo("Reinstalling cow CLI...")
-    subprocess.call(
-        [python, "-m", "pip", "install", "-e", ".", "-q"],
-        cwd=root,
-    )

-    # 4. Start service
-    click.echo("")
-    time.sleep(1)
-    ctx.invoke(start, no_logs=True)
+        # 4. Start service
+        click.echo("")
+        time.sleep(1)
+        ctx.invoke(start, no_logs=False)


@click.command()
--- a/cli/commands/skill.py
+++ b/cli/commands/skill.py
@@ -111,7 +111,7 @@ def _clone_repo(git_url: str):
        import subprocess
        subprocess.run(
            ["git", "clone", "--depth", "1", git_url, repo_dir],
-            check=True, capture_output=True, timeout=120,
+            check=True, capture_output=True, timeout=30,
        )
    except FileNotFoundError:
        shutil.rmtree(tmp_dir, ignore_errors=True)
@@ -122,7 +122,7 @@ def _clone_repo(git_url: str):
    return tmp_dir, repo_dir


-def _download_repo_zip(spec: str, branch: str = "main", host: str = "github"):
+def _download_repo_zip(spec: str, branch: str = "main", host: str = "github", timeout: int = 30):
    """Download a GitHub/GitLab repo as zip and extract it.

    Returns (tmp_dir, repo_root) where tmp_dir is the temp directory to clean up
@@ -132,7 +132,11 @@ def _download_repo_zip(spec: str, branch: str = "main", host: str = "github"):
        zip_url = f"https://gitlab.com/{spec}/-/archive/{branch}/{spec.split('/')[-1]}-{branch}.zip"
    else:
        zip_url = f"https://github.com/{spec}/archive/refs/heads/{branch}.zip"
-    resp = requests.get(zip_url, timeout=120, allow_redirects=True)
+    if isinstance(timeout, (list, tuple)):
+        req_timeout = timeout
+    else:
+        req_timeout = (min(timeout, 5), timeout)
+    resp = requests.get(zip_url, timeout=req_timeout, allow_redirects=True)
    resp.raise_for_status()

    tmp_dir = tempfile.mkdtemp(prefix="cow-skill-")
@@ -259,8 +263,9 @@ def _scan_skills_in_dir(directory: str) -> list:
    return found


-def _batch_install_skills(discovered, spec, skills_dir, source, result: InstallResult):
+def _batch_install_skills(discovered, spec, skills_dir, source, result: InstallResult, display_name: str = ""):
    """Install a list of discovered skills into skills_dir."""
+    single = len(discovered) == 1
    result.messages.append(f"Found {len(discovered)} skill(s) in {spec}:")
    for sname, sdir in discovered:
        safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '-', sname)[:64]
@@ -271,7 +276,7 @@ def _batch_install_skills(discovered, spec, skills_dir, source, result: InstallR
        if os.path.exists(target_dir):
            shutil.rmtree(target_dir)
        shutil.copytree(sdir, target_dir)
-        _register_installed_skill(safe_name, source=source)
+        _register_installed_skill(safe_name, source=source, display_name=display_name if single else "")
        result.installed.append(safe_name)
        result.messages.append(f"  + {safe_name}")

@@ -320,7 +325,7 @@ def _install_local(path: str, result: InstallResult):
    _batch_install_skills(discovered, path, skills_dir, "local", result)


-def _register_installed_skill(name: str, source: str = "cowhub"):
+def _register_installed_skill(name: str, source: str = "cowhub", display_name: str = ""):
    """Register a newly installed skill into skills_config.json.

    source values: builtin, cow, github, clawhub, linkai, local, url
@@ -337,18 +342,28 @@ def _register_installed_skill(name: str, source: str = "cowhub"):
            config = {}

    if name in config:
+        if display_name and not config[name].get("display_name"):
+            config[name]["display_name"] = display_name
+            try:
+                with open(config_path, "w", encoding="utf-8") as f:
+                    json.dump(config, f, indent=4, ensure_ascii=False)
+            except Exception:
+                pass
        return

    skill_dir = os.path.join(skills_dir, name)
    description = _read_skill_description(skill_dir) or ""

-    config[name] = {
+    entry = {
        "name": name,
        "description": description,
        "source": source,
        "enabled": True,
        "category": "skill",
    }
+    if display_name:
+        entry["display_name"] = display_name
+    config[name] = entry

    try:
        with open(config_path, "w", encoding="utf-8") as f:
@@ -419,15 +434,100 @@ def _install_url(url: str, result: InstallResult):
    result.messages.append(f"Installed '{skill_name}' from URL.")


+def _install_archive_url(url: str, result: InstallResult):
+    """Install skill(s) from a remote zip/tar.gz archive URL."""
+    parsed = urlparse(url)
+    if parsed.scheme != "https":
+        raise SkillInstallError("Refusing to download from non-HTTPS URL.")
+
+    filename = os.path.basename(parsed.path).split("?")[0]
+    fallback_name = re.sub(r'\.(zip|tar\.gz|tgz)$', '', filename, flags=re.IGNORECASE)
+    if not fallback_name or not _SAFE_NAME_RE.match(fallback_name):
+        fallback_name = "skill-package"
+
+    result.messages.append(f"Downloading archive from {url} ...")
+    try:
+        resp = requests.get(url, timeout=30, allow_redirects=True)
+        resp.raise_for_status()
+    except Exception as e:
+        raise SkillInstallError(f"Failed to download archive: {e}")
+
+    skills_dir = get_skills_dir()
+    os.makedirs(skills_dir, exist_ok=True)
+
+    content_type = resp.headers.get("Content-Type", "")
+    lower_url = url.lower()
+
+    if lower_url.endswith((".tar.gz", ".tgz")) or "gzip" in content_type:
+        _install_targz_bytes(resp.content, fallback_name, skills_dir, result)
+    else:
+        _install_zip_bytes(resp.content, fallback_name, skills_dir, result=result, source_label="url")
+
+
+def _install_targz_bytes(content: bytes, name: str, skills_dir: str, result: InstallResult):
+    """Extract a tar.gz archive and install skill(s)."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tar_path = os.path.join(tmp_dir, "package.tar.gz")
+        with open(tar_path, "wb") as f:
+            f.write(content)
+
+        import tarfile
+        extract_dir = os.path.join(tmp_dir, "extracted")
+        os.makedirs(extract_dir)
+        with tarfile.open(tar_path, "r:gz") as tf:
+            for member in tf.getmembers():
+                resolved = os.path.realpath(os.path.join(extract_dir, member.name))
+                if not resolved.startswith(os.path.realpath(extract_dir)):
+                    raise SkillInstallError("Archive contains path traversal, aborting.")
+            tf.extractall(extract_dir)
+
+        top_items = [d for d in os.listdir(extract_dir) if not d.startswith(".")]
+        pkg_root = extract_dir
+        if len(top_items) == 1 and os.path.isdir(os.path.join(extract_dir, top_items[0])):
+            pkg_root = os.path.join(extract_dir, top_items[0])
+
+        discovered = _scan_skills_in_repo(pkg_root) or _scan_skills_in_dir(pkg_root)
+
+        if discovered and len(discovered) > 1:
+            _batch_install_skills(discovered, name, skills_dir, "url", result)
+            return
+
+        if discovered and len(discovered) == 1:
+            sname, sdir = discovered[0]
+            safe_name = re.sub(r'[^a-zA-Z0-9_\\-]', '-', sname)[:64]
+            if not _SAFE_NAME_RE.match(safe_name):
+                safe_name = name
+            target = os.path.join(skills_dir, safe_name)
+            if os.path.exists(target):
+                shutil.rmtree(target)
+            shutil.copytree(sdir, target)
+            _register_installed_skill(safe_name, source="url")
+            result.installed.append(safe_name)
+            result.messages.append(f"Installed '{safe_name}' from URL.")
+            return
+
+        target = os.path.join(skills_dir, name)
+        if os.path.exists(target):
+            shutil.rmtree(target)
+        shutil.copytree(pkg_root, target)
+        _register_installed_skill(name, source="url")
+        result.installed.append(name)
+        result.messages.append(f"Installed '{name}' from URL.")
+
+
 def _print_install_success(name: str, source: str):
    """Print a unified install success message with description and source."""
    skills_dir = get_skills_dir()
+    config = load_skills_config()
+    display = config.get(name, {}).get("display_name", "")
    desc = _read_skill_description(os.path.join(skills_dir, name))
    click.echo(click.style(f"✓ {name}", fg="green"))
+    if display and display != name:
+        click.echo(f"  名称: {display}")
    if desc:
        if len(desc) > 60:
            desc = desc[:57] + "…"
-        click.echo(f"  {desc}")
+        click.echo(f"  描述: {desc}")
    click.echo(f"  来源: {source}")


@@ -463,14 +563,26 @@ def _check_github_spec(spec: str):
        raise SkillInstallError(f"Invalid GitHub spec '{spec}'. Expected format: owner/repo")


+_JUNK_NAMES = {'.DS_Store', 'Thumbs.db', 'desktop.ini'}
+
+
+def _is_junk_entry(filename: str) -> bool:
+    parts = filename.replace('\\', '/').split('/')
+    return any(p in _JUNK_NAMES or p == '__MACOSX' or p.startswith('._.') for p in parts)
+
+
 def _safe_extractall(zf: zipfile.ZipFile, dest: str):
-    """Extract zip while guarding against Zip Slip (path traversal)."""
+    """Extract zip while guarding against Zip Slip and filtering junk files."""
    dest = os.path.realpath(dest)
+    members = []
    for member in zf.infolist():
+        if _is_junk_entry(member.filename):
+            continue
        target = os.path.realpath(os.path.join(dest, member.filename))
        if not target.startswith(dest + os.sep) and target != dest:
            raise ValueError(f"Unsafe zip entry detected: {member.filename}")
-    zf.extractall(dest)
+        members.append(member)
+    zf.extractall(dest, members=members)


 def _verify_checksum(content: bytes, expected: str):
@@ -560,7 +672,15 @@ def _list_local():

 def _print_skill_table(entries):
    """Print skills as a formatted table."""
-    name_w = max(len(e.get("name", "")) for e in entries)
+    def _display_label(e):
+        display = e.get("display_name", "")
+        name = e.get("name", "")
+        if display and display != name:
+            return f"{display} ({name})"
+        return name
+
+    labels = [_display_label(e) for e in entries]
+    name_w = max((len(l) for l in labels), default=4)
    name_w = max(name_w, 4) + 2
    desc_w = 40

@@ -569,8 +689,7 @@ def _print_skill_table(entries):
    click.echo(f"  {header}")
    click.echo(f"  {'─' * (name_w + 10 + 10 + desc_w)}")

-    for e in entries:
-        name = e.get("name", "")
+    for e, label in zip(entries, labels):
        enabled = e.get("enabled", True)
        source = e.get("source", "")
        desc = e.get("description", "") or ""
@@ -578,7 +697,7 @@ def _print_skill_table(entries):
            desc = desc[:desc_w - 3] + "..."

        status_icon = click.style("✓ on ", fg="green") if enabled else click.style("✗ off", fg="red")
-        click.echo(f"  {name:<{name_w}} {status_icon}  {source:<10} {desc}")
+        click.echo(f"  {label:<{name_w}} {status_icon}  {source:<10} {desc}")

    click.echo()

@@ -634,7 +753,8 @@ def _list_remote(page: int = 1):
        nav_parts.append(f"cow skill list --remote --page {page + 1}")
    if nav_parts:
        click.echo(f"  Navigate: {' | '.join(nav_parts)}")
-    click.echo(f"  Install:  cow skill install <name>\n")
+    click.echo(f"  Install:  cow skill install <name>")
+    click.echo(f"  Browse:   https://skills.cowagent.ai\n")


 # ------------------------------------------------------------------
@@ -715,6 +835,11 @@ def _route_install(name: str, result: InstallResult):
        _install_url(name, result)
        return

+    # --- Zip / tar.gz archive URL ---
+    if name.startswith(("http://", "https://")) and re.search(r'\.(zip|tar\.gz|tgz)(\?.*)?$', name, re.IGNORECASE):
+        _install_archive_url(name, result)
+        return
+
    # --- Full GitHub URL ---
    parsed = _parse_github_url(name)
    if parsed:
@@ -742,8 +867,11 @@ def _route_install(name: str, result: InstallResult):
        subpath = None
        if "#" in raw:
            raw, subpath = raw.split("#", 1)
-        _check_github_spec(raw)
-        _install_github(raw, result, subpath=subpath)
+        if re.match(r"^[a-zA-Z0-9_\-]+/[a-zA-Z0-9_.\-]+$", raw):
+            _install_github(raw, result, subpath=subpath)
+        else:
+            _check_skill_name(raw)
+            _install_hub(raw, result, provider="github")
        return

    # --- clawhub: prefix ---
@@ -753,6 +881,15 @@ def _route_install(name: str, result: InstallResult):
        _install_hub(skill_name, result, provider="clawhub")
        return

+    # --- linkai: prefix ---
+    if name.startswith("linkai:"):
+        skill_code = name[7:]
+        # LinkAI codes can be mixed-case alphanumeric; validate loosely
+        if not re.match(r"^[a-zA-Z0-9_\-]{1,128}$", skill_code):
+            raise SkillInstallError(f"Invalid LinkAI skill code '{skill_code}'.")
+        _install_hub(skill_code, result, provider="linkai")
+        return
+
    # --- owner/repo or owner/repo#subpath shorthand ---
    if re.match(r"^[a-zA-Z0-9_\-]+/[a-zA-Z0-9_.\-]+(?:#.+)?$", name):
        subpath = None
@@ -832,22 +969,63 @@ def _install_hub(name, result: InstallResult, provider=None):
        raise SkillInstallError(f"Failed to connect to Skill Hub: {e}")

    content_type = resp.headers.get("Content-Type", "")
+    hub_display_name = ""

    if "application/json" in content_type:
        data = resp.json()
        source_type = data.get("source_type")
+        hub_display_name = data.get("display_name", "")

        if source_type == "github":
            source_url = data.get("source_url", "")
-            parsed_url = _parse_github_url(source_url)
-            if parsed_url:
-                owner, repo, branch, subpath = parsed_url
-                result.messages.append(f"Source: GitHub ({source_url})")
-                _install_github(f"{owner}/{repo}", result, subpath=subpath, skill_name=name, branch=branch)
-            else:
-                _check_github_spec(source_url)
-                result.messages.append(f"Source: GitHub ({source_url})")
-                _install_github(source_url, result, skill_name=name)
+            has_mirror = data.get("has_mirror", False)
+            gh_err = None
+
+            gh_timeout = 15 if has_mirror else 30
+            try:
+                parsed_url = _parse_github_url(source_url)
+                if parsed_url:
+                    owner, repo, branch, subpath = parsed_url
+                    _install_github(f"{owner}/{repo}", result, subpath=subpath, skill_name=name, branch=branch, timeout=gh_timeout)
+                else:
+                    _check_github_spec(source_url)
+                    _install_github(source_url, result, skill_name=name, timeout=gh_timeout)
+                if hub_display_name:
+                    _register_installed_skill(name, display_name=hub_display_name)
+                return
+            except Exception as e:
+                gh_err = e
+                if not has_mirror:
+                    raise SkillInstallError(f"GitHub download failed: {e}")
+
+            # Fallback: download mirror from Skill Hub
+            result.messages.append(f"GitHub download failed ({gh_err}), trying mirror...")
+            try:
+                mirror_resp = requests.post(
+                    f"{SKILL_HUB_API}/skills/{name}/download",
+                    json={"mirror": True},
+                    timeout=30,
+                )
+                mirror_resp.raise_for_status()
+            except Exception as e:
+                raise SkillInstallError(
+                    f"GitHub download failed ({gh_err}) and mirror also failed: {e}"
+                )
+
+            mirror_ct = mirror_resp.headers.get("Content-Type", "")
+            if "application/zip" not in mirror_ct:
+                raise SkillInstallError(
+                    f"GitHub download failed ({gh_err}) and mirror returned unexpected content."
+                )
+
+            expected_checksum = mirror_resp.headers.get("X-Checksum-Sha256")
+            _check_checksum(mirror_resp.content, expected_checksum)
+            installed_before = len(result.installed)
+            _install_zip_bytes(mirror_resp.content, name, skills_dir, result=result, source_label="cowhub", display_name=hub_display_name)
+            if len(result.installed) == installed_before:
+                _register_installed_skill(name, source="cowhub", display_name=hub_display_name)
+                result.installed.append(name)
+                result.messages.append(f"Installed '{name}' from mirror.")
            return

        if source_type == "registry":
@@ -857,21 +1035,60 @@ def _install_hub(name, result: InstallResult, provider=None):
                if parsed.scheme != "https":
                    raise SkillInstallError("Refusing to download from non-HTTPS URL.")
                src_provider = data.get("source_provider", "registry")
+                has_mirror = data.get("has_mirror", False)
                expected_checksum = data.get("checksum") or data.get("sha256")
                result.messages.append(f"Source: {src_provider}")
                result.messages.append("Downloading skill package...")
+                dl_err = None
+                dl_timeout = 15 if has_mirror else 30
                try:
-                    dl_resp = requests.get(download_url, timeout=60, allow_redirects=True)
+                    dl_resp = requests.get(
+                        download_url,
+                        timeout=(min(dl_timeout, 5), dl_timeout),
+                        allow_redirects=True,
+                    )
                    dl_resp.raise_for_status()
                except Exception as e:
-                    raise SkillInstallError(f"Failed to download from {src_provider}: {e}")
-                _check_checksum(dl_resp.content, expected_checksum)
+                    dl_err = e
+                    if not has_mirror:
+                        raise SkillInstallError(f"Failed to download from {src_provider}: {e}")
+
+                if dl_err is None:
+                    _check_checksum(dl_resp.content, expected_checksum)
+                    installed_before = len(result.installed)
+                    _install_zip_bytes(dl_resp.content, name, skills_dir, result=result, source_label=src_provider, display_name=hub_display_name)
+                    if len(result.installed) == installed_before:
+                        _register_installed_skill(name, source=src_provider, display_name=hub_display_name)
+                        result.installed.append(name)
+                        result.messages.append(f"Installed '{name}' from {src_provider}.")
+                    return
+
+                # Fallback: download mirror from Skill Hub
+                result.messages.append(f"Direct download failed ({dl_err}), trying mirror...")
+                try:
+                    mirror_resp = requests.post(
+                        f"{SKILL_HUB_API}/skills/{name}/download",
+                        json={"mirror": True},
+                        timeout=30,
+                    )
+                    mirror_resp.raise_for_status()
+                except Exception as e:
+                    raise SkillInstallError(
+                        f"Direct download failed ({dl_err}) and mirror also failed: {e}"
+                    )
+                mirror_ct = mirror_resp.headers.get("Content-Type", "")
+                if "application/zip" not in mirror_ct:
+                    raise SkillInstallError(
+                        f"Direct download failed ({dl_err}) and mirror returned unexpected content."
+                    )
+                expected_checksum = mirror_resp.headers.get("X-Checksum-Sha256")
+                _check_checksum(mirror_resp.content, expected_checksum)
                installed_before = len(result.installed)
-                _install_zip_bytes(dl_resp.content, name, skills_dir, result=result, source_label=src_provider)
+                _install_zip_bytes(mirror_resp.content, name, skills_dir, result=result, source_label="cowhub", display_name=hub_display_name)
                if len(result.installed) == installed_before:
-                    _register_installed_skill(name, source=src_provider)
+                    _register_installed_skill(name, source="cowhub", display_name=hub_display_name)
                    result.installed.append(name)
-                    result.messages.append(f"Installed '{name}' from {src_provider}.")
+                    result.messages.append(f"Installed '{name}' from mirror.")
            else:
                raise SkillInstallError("Unsupported registry provider.")
            return
@@ -881,12 +1098,12 @@ def _install_hub(name, result: InstallResult, provider=None):
            parsed_url = _parse_github_url(source_url)
            if parsed_url:
                owner, repo, branch, subpath = parsed_url
-                result.messages.append(f"Source: GitHub ({source_url})")
                _install_github(f"{owner}/{repo}", result, subpath=subpath, skill_name=name, branch=branch)
            else:
                _check_github_spec(source_url)
-                result.messages.append(f"Source: GitHub ({source_url})")
                _install_github(source_url, result, skill_name=name)
+            if hub_display_name:
+                _register_installed_skill(name, display_name=hub_display_name)
            return

    elif "application/zip" in content_type:
@@ -904,7 +1121,7 @@ def _install_hub(name, result: InstallResult, provider=None):
    raise SkillInstallError("Unexpected response from Skill Hub.")


-def _install_github(spec, result: InstallResult, subpath=None, skill_name=None, branch="main", source="github"):
+def _install_github(spec, result: InstallResult, subpath=None, skill_name=None, branch="main", source="github", timeout=30):
    """Install skill(s) from a GitHub repo.

    Strategy: zip download first (no API rate limit), Contents API as fallback.
@@ -923,7 +1140,7 @@ def _install_github(spec, result: InstallResult, subpath=None, skill_name=None,
    tmp_dir = None
    repo_root = None
    try:
-        tmp_dir, repo_root = _download_repo_zip(spec, branch)
+        tmp_dir, repo_root = _download_repo_zip(spec, branch, timeout=timeout)
    except Exception:
        result.messages.append("Zip download failed, falling back to Contents API...")

@@ -1056,7 +1273,7 @@ def _install_git_clone(git_url: str, result: InstallResult, display_name: str =
        shutil.rmtree(tmp_dir, ignore_errors=True)


-def _install_zip_bytes(content, name, skills_dir, result: InstallResult = None, source_label: str = "zip"):
+def _install_zip_bytes(content, name, skills_dir, result: InstallResult = None, source_label: str = "zip", display_name: str = ""):
    """Extract a zip archive and install skill(s).

    Supports three scenarios:
@@ -1081,7 +1298,7 @@ def _install_zip_bytes(content, name, skills_dir, result: InstallResult = None,
        discovered = _scan_skills_in_repo(pkg_root) or _scan_skills_in_dir(pkg_root)

        if discovered and len(discovered) > 1 and result is not None:
-            _batch_install_skills(discovered, name, skills_dir, source_label, result)
+            _batch_install_skills(discovered, name, skills_dir, source_label, result, display_name=display_name)
            return

        if discovered and len(discovered) == 1:
@@ -1093,7 +1310,7 @@ def _install_zip_bytes(content, name, skills_dir, result: InstallResult = None,
            if os.path.exists(target):
                shutil.rmtree(target)
            shutil.copytree(sdir, target)
-            _register_installed_skill(safe_name, source=source_label)
+            _register_installed_skill(safe_name, source=source_label, display_name=display_name)
            if result is not None:
                result.installed.append(safe_name)
                result.messages.append(f"Installed '{safe_name}' from {source_label}.")
@@ -1228,7 +1445,10 @@ def info(name):
    enabled = entry.get("enabled", True)
    status_str = click.style("✓ enabled", fg="green") if enabled else click.style("✗ disabled", fg="red")

+    display_name = entry.get("display_name", "")
    click.echo(f"\n  Skill: {name}")
+    if display_name and display_name != name:
+        click.echo(f"  Display: {display_name}")
    click.echo(f"  Source: {source}")
    click.echo(f"  Status: {status_str}")
    click.echo(f"  Path: {skill_dir}")
--- a/common/cloud_client.py
+++ b/common/cloud_client.py
@@ -47,13 +47,14 @@ CREDENTIAL_MAP = {


 class CloudClient(LinkAIClient):
-    def __init__(self, api_key: str, channel, host: str = ""):
-        super().__init__(api_key, host)
+    def __init__(self, api_key: str, channel, host: str = "", port=None):
+        super().__init__(api_key, host, port=port)
        self.channel = channel
        self.client_type = channel.channel_type
        self.channel_mgr = None
        self._skill_service = None
        self._memory_service = None
+        self._knowledge_service = None
        self._chat_service = None

    @property
@@ -88,6 +89,21 @@ class CloudClient(LinkAIClient):
                logger.error(f"[CloudClient] Failed to init MemoryService: {e}")
        return self._memory_service

+    @property
+    def knowledge_service(self):
+        """Lazy-init KnowledgeService."""
+        if self._knowledge_service is None:
+            try:
+                from agent.knowledge.service import KnowledgeService
+                from config import conf
+                from common.utils import expand_path
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
+                self._knowledge_service = KnowledgeService(workspace_root)
+                logger.debug("[CloudClient] KnowledgeService initialised")
+            except Exception as e:
+                logger.error(f"[CloudClient] Failed to init KnowledgeService: {e}")
+        return self._knowledge_service
+
    @property
    def chat_service(self):
        """Lazy-init ChatService (requires AgentBridge via Bridge singleton)."""
@@ -468,6 +484,27 @@ class CloudClient(LinkAIClient):

        return svc.dispatch(action, payload)

+    # ------------------------------------------------------------------
+    # knowledge callback
+    # ------------------------------------------------------------------
+    def on_knowledge(self, data: dict) -> dict:
+        """
+        Handle KNOWLEDGE messages from the cloud console.
+        Delegates to KnowledgeService.dispatch for the actual operations.
+
+        :param data: message data with 'action', 'clientId', 'payload'
+        :return: response dict
+        """
+        action = data.get("action", "")
+        payload = data.get("payload")
+        logger.info(f"[CloudClient] on_knowledge: action={action}")
+
+        svc = self.knowledge_service
+        if svc is None:
+            return {"action": action, "code": 500, "message": "KnowledgeService not available", "payload": None}
+
+        return svc.dispatch(action, payload)
+
    # ------------------------------------------------------------------
    # chat callback
    # ------------------------------------------------------------------
@@ -487,6 +524,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")
@@ -629,9 +679,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:
@@ -648,6 +698,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.

@@ -668,8 +754,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. **必须发送链接**: 无论是网页还是文件，生成后**必须将完整的访问/下载链接直接写在回复文本中发送给用户**",
        "",
@@ -684,7 +770,7 @@ def start(channel, channel_mgr=None):
        return

    global chat_client
-    chat_client = CloudClient(api_key=conf().get("linkai_api_key"), host=conf().get("cloud_host", ""), channel=channel)
+    chat_client = CloudClient(api_key=conf().get("linkai_api_key"), host=conf().get("cloud_host", ""), port=conf().get("cloud_port"), channel=channel)
    chat_client.channel_mgr = channel_mgr
    chat_client.config = _build_config()
    chat_client.start()
--- a/common/const.py
+++ b/common/const.py
@@ -7,8 +7,8 @@ XUNFEI = "xunfei"
 CHATGPTONAZURE = "chatGPTOnAzure"
 LINKAI = "linkai"
 CLAUDEAPI= "claudeAPI"
-QWEN = "qwen"  # 旧版千问接入
-QWEN_DASHSCOPE = "dashscope"  # 新版千问接入(百炼)
+QWEN = "qwen"  # 千问 (兼容旧配置，实际走 DashscopeBot)
+QWEN_DASHSCOPE = "dashscope"  # 千问 DashScope 接入
 GEMINI = "gemini" 
 ZHIPU_AI = "zhipu"  
 MOONSHOT = "moonshot"
@@ -81,18 +81,19 @@ TTS_1_HD = "tts-1-hd"
 DEEPSEEK_CHAT = "deepseek-chat"  # DeepSeek-V3对话模型
 DEEPSEEK_REASONER = "deepseek-reasoner"  # DeepSeek-R1模型

-# Qwen (通义千问 - 阿里云)
-QWEN = "qwen"
+# Qwen (通义千问 - 阿里云 DashScope)
 QWEN_TURBO = "qwen-turbo"
 QWEN_PLUS = "qwen-plus"
 QWEN_MAX = "qwen-max"
 QWEN_LONG = "qwen-long"
 QWEN3_MAX = "qwen3-max"  # Qwen3 Max - Agent推荐模型
 QWEN35_PLUS = "qwen3.5-plus"  # Qwen3.5 Plus - Omni model (MultiModalConversation)
+QWEN36_PLUS = "qwen3.6-plus"  # Qwen3.6 Plus - Omni model (MultiModalConversation)
 QWQ_PLUS = "qwq-plus"

 # MiniMax
 MINIMAX_M2_7 = "MiniMax-M2.7"  # MiniMax M2.7 - Latest
+MINIMAX_M2_7_HIGHSPEED = "MiniMax-M2.7-highspeed"  # MiniMax M2.7 highspeed
 MINIMAX_M2_5 = "MiniMax-M2.5"  # MiniMax M2.5
 MINIMAX_M2_1 = "MiniMax-M2.1"  # MiniMax M2.1
 MINIMAX_M2_1_LIGHTNING = "MiniMax-M2.1-lightning"  # MiniMax M2.1 极速版
@@ -124,6 +125,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 +140,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
@@ -165,10 +173,10 @@ MODEL_LIST = [
              DEEPSEEK_CHAT, DEEPSEEK_REASONER,
              
              # Qwen
-              QWEN, QWEN_TURBO, QWEN_PLUS, QWEN_MAX, QWEN_LONG, QWEN3_MAX, QWEN35_PLUS,
+              QWEN36_PLUS, QWEN35_PLUS, QWEN3_MAX, QWEN_MAX, QWEN_PLUS, QWEN_TURBO, QWEN_LONG,
              
              # MiniMax
-              MiniMax, MINIMAX_M2_7, MINIMAX_M2_5, MINIMAX_M2_1, MINIMAX_M2_1_LIGHTNING, MINIMAX_M2, MINIMAX_ABAB6_5,
+              MiniMax, MINIMAX_M2_7, MINIMAX_M2_7_HIGHSPEED, MINIMAX_M2_5, MINIMAX_M2_1, MINIMAX_M2_1_LIGHTNING, MINIMAX_M2, MINIMAX_ABAB6_5,

              # GLM
              ZHIPU_AI, GLM_5_TURBO, GLM_5, GLM_4, GLM_4_PLUS, GLM_4_flash, GLM_4_LONG, GLM_4_ALLTOOLS,
--- a/common/log.py
+++ b/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",
--- a/config-template.json
+++ b/config-template.json
@@ -26,8 +26,10 @@
  "dingtalk_client_secret":"",
  "wecom_bot_id": "",
  "wecom_bot_secret": "",
+  "web_password": "",
  "agent": true,
-  "agent_max_context_tokens": 40000,
+  "agent_max_context_tokens": 50000,
  "agent_max_context_turns": 20,
-  "agent_max_steps": 15
+  "agent_max_steps": 20,
+  "knowledge": true
 }
--- a/config.py
+++ b/config.py
@@ -180,25 +180,30 @@ available_setting = {
    # 豆包(火山方舟) 平台配置
    "ark_api_key": "",
    "ark_base_url": "https://ark.cn-beijing.volces.com/api/v3",
-    #魔搭社区 平台配置
+    # 魔搭社区 平台配置
    "modelscope_api_key": "",
    "modelscope_base_url": "https://api-inference.modelscope.cn/v1/chat/completions",
    # LinkAI平台配置
    "use_linkai": False,
    "linkai_api_key": "",
    "linkai_app_code": "",
-    "linkai_api_base": "https://api.link-ai.tech",  # linkAI服务地址
+    "linkai_api_base": "https://api.link-ai.tech",
    "cloud_host": "client.link-ai.tech",
+    "cloud_port": None,
    "cloud_deployment_id": "",
    "minimax_api_key": "",
    "Minimax_group_id": "",
    "Minimax_base_url": "",
    "web_port": 9899,
+    "web_password": "",  # Web console password; empty means no authentication required
+    "web_session_expire_days": 30,  # Auth session expiry in days
    "agent": True,  # 是否开启Agent模式
    "agent_workspace": "~/cow",  # agent工作空间路径，用于存储skills、memory等
    "agent_max_context_tokens": 50000,  # Agent模式下最大上下文tokens
-    "agent_max_context_turns": 30,  # Agent模式下最大上下文记忆轮次
-    "agent_max_steps": 15,  # Agent模式下单次运行最大决策步数
+    "agent_max_context_turns": 20,  # Agent模式下最大上下文记忆轮次
+    "agent_max_steps": 20,  # Agent模式下单次运行最大决策步数
+    "enable_thinking": True,  # Whether to enable deep thinking for web channel
+    "knowledge": True,  # 是否开启知识库功能
 }


@@ -408,7 +413,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()


--- a/docker/Dockerfile.latest
+++ b/docker/Dockerfile.latest
@@ -4,29 +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 --no-cache -r requirements-optional.txt \
+    && 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
+    && chown agent:agent /entrypoint.sh

 ENTRYPOINT ["/entrypoint.sh"]
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -35,9 +35,10 @@ services:
      DINGTALK_CLIENT_SECRET: ''
      WECOM_BOT_ID: ''
      WECOM_BOT_SECRET: ''
+      WEB_PASSWORD: ''
      AGENT: 'True'
-      AGENT_MAX_CONTEXT_TOKENS: 40000
+      AGENT_MAX_CONTEXT_TOKENS: 50000
      AGENT_MAX_CONTEXT_TURNS: 20
-      AGENT_MAX_STEPS: 15
+      AGENT_MAX_STEPS: 20
    volumes:
      - ./cow:/home/agent/cow
--- a/docs/agent.md
+++ b/docs/agent.md
@@ -1,185 +0,0 @@
-# CowAgent介绍
-
-## 概述
-
-Cow项目从简单的聊天机器人全面升级为超级智能助理 **CowAgent**，能够主动规思考和规划任务、拥有长期记忆、操作计算机和外部资源、创造和执行Skill，真正理解你并和你一起成长。CowAgent能够长期运行在个人电脑或服务器中，通过飞书、钉钉、企业微信、网页等多种方式进行交互。核心能力如下：
-
- **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持多轮推理和上下文理解
- **工具系统**：内置实现10+种工具，包括文件读写、bash终端、浏览器、定时任务、记忆管理等，通过Agent管理你的计算机或服务器
- **长期记忆**：自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索
- **Skills系统**：新增Skill运行引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发
- **多渠道和多模型支持**：支持在Web、飞书、钉钉、企微等多渠道与Agent交互，支持Claude、Gemini、OpenAI、GLM、MiniMax、Qwen、Kimi、Doubao 等多种国内外主流模型
- **安全和成本**：通过秘钥管理工具、提示词控制、系统权限等手段控制Agent的访问安全；通过最大记忆轮次、最大上下文token、工具执行步数对token成本进行限制
-
-
-## 核心功能
-
-### 1. 长期记忆
-
-> 记忆系统让 Agent 能够长期记住重要信息。Agent 会在用户分享偏好、决策、事实等重要信息时主动存储，也会在对话达到一定长度时自动提取摘要。记忆分为核心记忆、天级记忆，支持语义搜索和向量检索的混合检索模式。
-
-
-第一次启动Agent会主动向用户获取询问关键信息，并记录至工作空间 (默认为 ~/cow) 中的智能体设定、用户身份、记忆文件中。
-
-在后续的长期对话中，Agent会在需要的时候智能记录或检索记忆，并对自身设定、用户偏好、记忆文件等进行不断更新，总结和记录经验和教训，真正实现自主思考和不断成长。
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260203000455.png" />
-
-
-
-### 2. 任务规划和工具调用
-
-工具是Agent访问操作系统资源的核心，Agent会根据任务需求智能选择和调用工具，完成文件读写、命令执行、定时任务等各类操作。内置工具的视线在项目的 `tools` 目录下。
-
-**主要工具：** 文件读写编辑、Bash终端、浏览器、文件发送、定时调度、记忆搜索、环境配置等。
-
-#### 1.1 终端和文件访问能力
-
-针对操作系统的终端和文件的访问能力，是最基础和核心的工具，其他很多工具或技能都是基于基础工具进行扩展。用户可通过手机端与Agent交互，操作个人电脑或服务器上的资源：
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260202181130.png" />
-
-#### 1.2 编程能力
-
-基于编程能力和系统访问能力，Agent可以实现从信息搜索、图片等素材生成、编码、测试、部署、Nginx配置修改、发布的 Vibecoding 全流程，通过手机端简单的一句命令完成应用的快速demo：
-
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260203121008.png" />
-
-
-
-#### 1.3 定时任务
-
-基于 scheduler 工具实现动态定时任务，支持 **一次性任务、固定时间间隔、Cron表达式** 三种形式，任务触发可选择**固定消息发送** 或 **Agent动态任务** 执行两种模式，有很高灵活性：
-
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260202195402.png" />
-
-同时你也可以通过自然语言快速查看和管理已有的定时任务。
-
-
-#### 1.4 环境变量管理
-
-技能所需要的秘钥存储在环境变量文件中，由 `env_config` 工具进行管理，你可以通过对话的方式更新秘钥，工具内置了安全保护和脱敏策略，会严格保护秘钥安全：
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260202234939.png" />
-
-### 3. 技能系统
-
-> 技能系统为Agent提供无限的扩展性，每个Skill由说明文件、运行脚本 (可选)、资源 (可选) 组成，描述如何完成特定类型的任务。通过Skill可以让Agent遵循说明完成复杂流程，调用各类工具或对接第三方系统等。
-
- **内置技能：** 在项目的`skills`目录下，包含技能创造器、网络搜索、图像识别（openai-image-vision）、LinkAI智能体、网页抓取等。内置Skill根据依赖条件 (API Key、系统命令等) 自动判断是否启用。通过技能创造器可以快速创建自定义技能。
-
- **自定义技能：** 由用户通过对话创建，存放在工作空间中 (`~/cow/skills/`)，基于自定义技能可以实现任何复杂的业务流程和第三方系统对接。
-
-
-#### 3.1 创建技能
-
-通过 `skill-creator` 技能可以通过对话的方式快速创建技能。你可以在与Agent的写作中让他对将某个工作流程固化为技能，或者把任意接口文档和示例发送给Agent，让他直接完成对接：
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260202202247.png" />
-
-
-#### 3.2 搜索和图像识别
-
- **搜索技能：** 系统内置实现了 `bocha-search`(博查搜索)的Skill，依赖环境变量 `BOCHA_SEARCH_API_KEY`，可在[控制台](https://open.bochaai.com/)进行创建，并发送给Agent完成配置
- **图像识别技能：** 实现了 `openai-image-vision` 插件，可使用 gpt-4.1-mini、gpt-4.1 等图像识别模型。依赖秘钥 `OPENAI_API_KEY`，可通过config.json或env_config工具进行维护。
-
-<img width="800" src="https://cdn.link-ai.tech/doc/20260202213219.png" />
-
-
-#### 3.3 三方知识库和插件
-
-`linkai-agent` 技能可以将 [LinkAI](https://link-ai.tech/) 上的所有智能体作为skill交给Agent使用，并实现多智能体决策的效果。
-
-使用方式：需通过对话的方式配置 `LINKAI_API_KEY`，或在config.json中添加 `linkai_api_key`。 并在 `skills/linkai-agent/config.json`中添加智能体说明，示例如下：
-
-```json
-{
-  "apps": [
-    {
-      "app_code": "G7z6vKwp",
-      "app_name": "LinkAI客服助手",
-      "app_description": "当用户需要了解LinkAI平台相关问题时才选择该助手，基于LinkAI知识库进行回答"
-    },
-    {
-      "app_code": "SFY5x7JR",
-      "app_name": "内容创作助手",
-      "app_description": "当用户需要创作图片或视频时才使用该助手，支持Nano Banana、Seedream、即梦、Veo、可灵等多种模型"
-    }
-  ]
-}
-```
-
-Agent可根据智能体的名称和描述进行决策，并通过 app_code 调用接口访问对应的应用/工作流，通过该技能，可以灵活访问LinkAI平台上的智能体、知识库、插件等能力，实现效果如下：
-
-<img width="750" src="https://cdn.link-ai.tech/doc/20260202234350.png" />
-
-注：需通过 `env_config` 配置 `LINKAI_API_KEY`，或在config.json中添加 `linkai_api_key` 配置。
-
-
-## 使用方式
-
-> 详细使用方式参考项目README.md文档进行
-
-### 1.项目运行
-
-在命令行中执行：
-
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
-
-详细说明及后续程序管理参考：[项目启动脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/CowAgentQuickStart)
-
-
-### 2.模型选择
-
-Agent模式推荐使用以下模型，可根据效果及成本综合选择：
-
- **MiniMax**: `MiniMax-M2.7`
- **GLM**: `glm-5-turbo`
- **Kimi**: `kimi-k2.5`
- **Doubao**: `doubao-seed-2-0-code-preview-260215`
- **Qwen**: `qwen3.5-plus`
- **Claude**: `claude-sonnet-4-6`
- **Gemini**: `gemini-3.1-flash-lite-preview`
- **OpenAI**: `gpt-5.4`
-
-详细模型配置方式参考 [README.md 模型说明](../README.md#模型说明)
-
-### 3.Agent核心配置
-
-Agent模式的核心配置项如下，在 `config.json` 中配置：
-
-```bash
-{
-  "agent": true,                           # 是否启用Agent模式
-  "agent_workspace": "~/cow",              # Agent工作空间路径
-  "agent_max_context_tokens": 40000,       # 最大上下文tokens
-  "agent_max_context_turns": 30,           # 最大上下文记忆轮次
-  "agent_max_steps": 15                    # 单次任务最大决策步数
-}
-```
-
-**配置说明：**
-
- `agent`: 设为 `true` 启用Agent模式，获得多轮工具决策、长期记忆、Skills等能力
- `agent_workspace`: 工作空间路径，用于存储 memory、skills、其他系统设定提示词
- `agent_max_context_tokens`: 上下文token上限，超出将自动丢弃最早的对话
- `agent_max_context_turns`: 上下文记忆轮次，每轮包括一次提问和回复
- `agent_max_steps`: 单次任务最大工具调用步数，防止无限循环
-
-
-### 4.渠道接入
-
-Agent支持在多种渠道中使用，只需修改 `config.json` 中的 `channel_type` 配置即可切换。
-
- **Web网页**：默认使用该渠道，运行后监听本地端口，通过浏览器访问
- **飞书接入**：[飞书接入文档](https://docs.link-ai.tech/cow/multi-platform/feishu)
- **钉钉接入**：[钉钉接入文档](https://docs.link-ai.tech/cow/multi-platform/dingtalk)
- **企业微信应用接入**：[企微应用文档](https://docs.link-ai.tech/cow/multi-platform/wechat-com)
- **企微智能机器人**：[企微智能机器人文档](https://docs.link-ai.tech/cow/multi-platform/wecom-bot)
- **QQ机器人**：[QQ机器人文档](https://docs.link-ai.tech/cow/multi-platform/qq)
-
-更多渠道配置参考：[通道说明](../README.md#通道说明)
--- a/docs/channels/web.mdx
+++ b/docs/channels/web.mdx
@@ -10,7 +10,9 @@ Web 控制台是 CowAgent 的默认通道，启动后会自动运行，通过浏
 ```json
 {
  "channel_type": "web",
-  "web_port": 9899
+  "web_port": 9899,
+  "web_password": "",
+  "enable_thinking": true
 }
 ```

@@ -18,6 +20,11 @@ Web 控制台是 CowAgent 的默认通道，启动后会自动运行，通过浏
 | --- | --- | --- |
 | `channel_type` | 设为 `web` | `web` |
 | `web_port` | Web 服务监听端口 | `9899` |
+| `web_password` | 访问密码，留空表示不启用密码保护 | `""` |
+| `web_session_expire_days` | 登录会话有效天数 | `30` |
+| `enable_thinking` | 是否启用深度思考，开启后 Web 端展示推理过程，关闭可加速响应 | `true` |
+
+配置密码后，访问控制台时需先输入密码完成登录。登录状态默认保持 30 天，期间重启服务也无需重新登录。密码也支持在控制台的「配置」页面中在线修改。

 ## 访问地址

@@ -34,10 +41,20 @@ Web 控制台是 CowAgent 的默认通道，启动后会自动运行，通过浏

 ### 对话界面

-支持流式输出，可实时展示 Agent 的思考过程（Reasoning）和工具调用过程（Tool Calls），更直观地观察 Agent 的决策过程：
+支持流式输出，可实时展示 Agent 的思考过程（Reasoning）和工具调用过程（Tool Calls），更直观地观察 Agent 的决策过程。深度思考功能可通过配置或控制台的「Agent 配置」开关控制。

 <img width="850" src="https://cdn.link-ai.tech/doc/20260227180120.png" />

+#### 多会话管理
+
+对话界面支持多会话（Session）管理，所有会话记录持久化存储在数据库中：
+
+- **会话列表**：点击左侧历史会话图标可展开/收起会话列表面板，支持滚动加载全部历史会话
+- **AI 生成标题**：新会话在首轮对话完成后，自动调用模型生成简短的会话摘要标题
+- **新建会话**：点击会话列表顶部的「新对话」按钮或输入区的 `+` 按钮创建新会话
+- **删除会话**：点击会话项的删除按钮，确认后永久删除该会话及其所有消息
+- **清除上下文**：点击输入区的清除按钮，在当前会话中插入一条分隔线，分隔线以上的消息仍然展示但不再作为模型的上下文输入
+
 ### 模型管理

 支持在线管理模型配置，无需手动编辑配置文件：
--- a/docs/channels/wecom-bot.mdx
+++ b/docs/channels/wecom-bot.mdx
@@ -9,7 +9,23 @@ description: 将 CowAgent 接入企业微信智能机器人（长连接模式）
  智能机器人与企业微信自建应用是两种不同的接入方式。智能机器人使用 WebSocket 长连接，无需服务器公网 IP 和域名，配置更简单。
 </Note>

-## 一、创建智能机器人
+## 一、接入方式
+
+### 方式一：扫码一键接入（推荐）
+
+无需提前创建机器人，启动 Cow 项目后打开 Web 控制台（本地链接：http://127.0.0.1:9899/），选择 **通道** 菜单，点击**接入通道**，选择**企微智能机器人**，切换到「扫码接入」模式，使用**企业微信**扫码即可自动完成机器人创建和接入。
+
+<img src="https://cdn.link-ai.tech/doc/20260401121213.png" width="800"/>
+
+<Note>
+  扫码成功后，可在企业微信工作台 - **智能机器人**页面对机器人进行进一步配置，包括修改名称、头像、可见范围等。
+</Note>
+
+### 方式二：手动创建接入
+
+需要先在企业微信中创建智能机器人并获取 Bot ID 和 Secret，再通过 Web 控制台或配置文件接入。
+
+**步骤一：创建智能机器人**

 1. 打开企业微信客户端，进入工作台，点击**智能机器人**：

@@ -25,34 +41,35 @@ description: 将 CowAgent 接入企业微信智能机器人（长连接模式）

 4. 设置机器人名称、头像、可见范围，并选择**长连接模式**，记录下 **Bot ID** 和 **Secret** 信息后点击保存。

-## 二、配置和运行
+**步骤二：接入 CowAgent**

-### 方式一：Web 控制台接入
+<Tabs>
+  <Tab title="Web 控制台">
+    打开 Web 控制台，选择**通道**菜单，点击**接入通道**，选择**企微智能机器人**，切换到「手动填写」模式，输入 Bot ID 和 Secret，点击接入即可。

-启动Cow项目后打开 Web 控制台 (本地链接为: http://127.0.0.1:9899/ )，选择 **通道** 菜单，点击 **接入通道**，选择 **企微智能机器人**，填写上一步保存的 Bot ID 和 Secret，点击接入即可。
+    <img src="https://cdn.link-ai.tech/doc/20260316181711.png" width="800"/>
+  </Tab>
+  <Tab title="配置文件">
+    在 `config.json` 中添加以下配置后启动程序：

-<img src="https://cdn.link-ai.tech/doc/20260316181711.png" width="800"/>
+    ```json
+    {
+      "channel_type": "wecom_bot",
+      "wecom_bot_id": "YOUR_BOT_ID",
+      "wecom_bot_secret": "YOUR_SECRET"
+    }
+    ```

-### 方式二：配置文件接入
+    | 参数 | 说明 |
+    | --- | --- |
+    | `wecom_bot_id` | 智能机器人的 BotID |
+    | `wecom_bot_secret` | 智能机器人的 Secret |
+  </Tab>
+</Tabs>

-在 `config.json` 中添加以下配置：
+日志显示 `[WecomBot] Subscribe success` 即表示连接成功。

-```json
-{
-  "channel_type": "wecom_bot",
-  "wecom_bot_id": "YOUR_BOT_ID",
-  "wecom_bot_secret": "YOUR_SECRET"
-}
-```
-
-| 参数 | 说明 |
-| --- | --- |
-| `wecom_bot_id` | 智能机器人的 BotID |
-| `wecom_bot_secret` | 智能机器人的 Secret |
-
-配置完成后启动程序，日志显示 `[WecomBot] Subscribe success` 即表示连接成功。
-
-## 三、功能说明
+## 二、功能说明

 | 功能 | 支持情况 |
 | --- | --- |
@@ -64,7 +81,7 @@ description: 将 CowAgent 接入企业微信智能机器人（长连接模式）
 | 流式回复 | ✅ |
 | 定时任务主动推送 | ✅ |

-## 四、使用
+## 三、使用

 在企业微信中搜索创建的机器人名称，即可开始单聊对话。

--- a/docs/cli/general.mdx
+++ b/docs/cli/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
+```
--- a/docs/cli/index.mdx
+++ b/docs/cli/index.mdx
@@ -0,0 +1,96 @@
+---
+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 ...)
+
+Memory & Knowledge:
+  memory    Memory distillation (dream)
+  knowledge View knowledge base stats and structure
+
+Others:
+  help      Show this help message
+  version   Show version
+```
+
+## 对话命令
+
+在 Web 控制台或任意接入渠道的对话中，支持输入以 `/` 开头的命令：
+
+| 命令 | 说明 |
+| --- | --- |
+| `/help` | 显示命令帮助 |
+| `/status` | 查看服务状态和配置 |
+| `/config` | 查看或修改运行时配置 |
+| `/skill` | 管理技能（安装、卸载、启用、禁用等） |
+| `/memory dream [N]` | 手动触发记忆蒸馏（默认 3 天，最大 30） |
+| `/knowledge` | 查看知识库统计信息 |
+| `/knowledge list` | 查看知识库目录结构 |
+| `/knowledge on\|off` | 开启或关闭知识库 |
+| `/context` | 查看当前会话上下文信息 |
+| `/context clear` | 清空当前会话上下文 |
+| `/logs` | 查看最近日志 |
+| `/version` | 显示版本号 |
+
+<Tip>
+  对话命令中 `/start`、`/stop`、`/restart` 等服务管理命令会提示到终端中执行，因为它们涉及进程操作。
+</Tip>
+
+## 命令对照表
+
+以下是各命令在终端和对话中的可用性：
+
+| 命令 | 终端 (`cow`) | 对话 (`/`) |
+| --- | :---: | :---: |
+| help | ✓ | ✓ |
+| version | ✓ | ✓ |
+| status | ✓ | ✓ |
+| logs | ✓ | ✓ |
+| config | ✗ | ✓ |
+| context | — | ✓ |
+| memory (子命令) | ✗ | ✓ |
+| knowledge (子命令) | ✓ | ✓ |
+| skill (子命令) | ✓ | ✓ |
+| start / stop / restart | ✓ | ✗ |
+| update | ✓ | ✗ |
+| install-browser | ✓ | ✗ |
+
+<Note>
+  `context` 在终端中仅提示到对话中使用。`config` 仅支持在对话中修改。
+</Note>
--- a/docs/cli/memory-knowledge.mdx
+++ b/docs/cli/memory-knowledge.mdx
@@ -0,0 +1,77 @@
+---
+title: 记忆与知识库
+description: 记忆蒸馏和知识库管理命令
+---
+
+## memory
+
+管理 Agent 的长期记忆系统。
+
+### memory dream
+
+手动触发记忆蒸馏（Deep Dream），整理近期的天级记忆，蒸馏合并到 MEMORY.md，并生成梦境日记。
+
+```text
+/memory dream [N]
+```
+
+- `N`：整理近 N 天的记忆，默认 3 天，最大 30 天
+- 蒸馏在后台异步执行，完成后会在对话中通知结果
+- 无需等待 Agent 初始化，首次对话前即可使用
+
+**示例：**
+
+```text
+/memory dream       # 整理近 3 天
+/memory dream 7     # 整理近 7 天
+/memory dream 30    # 整理近 30 天（全量）
+```
+
+蒸馏完成后，Web 端会收到带有跳转链接的通知，可直接查看更新后的 MEMORY.md 和梦境日记。
+
+<Tip>
+  系统每天 23:55 会自动执行一次蒸馏（lookback 1 天）。手动触发适用于首次部署后的历史整理，或需要立即更新记忆时使用。
+</Tip>
+
+## knowledge
+
+查看和管理个人知识库。默认显示知识库统计信息。
+
+```text
+/knowledge
+```
+
+输出示例：
+
+```
+📚 知识库
+
+- 状态：已开启
+- 页面数：12
+- 总大小：45.2 KB
+- 分类明细：
+  - concepts/: 5 篇
+  - entities/: 4 篇
+  - sources/: 3 篇
+```
+
+### knowledge list
+
+查看知识库目录树结构。
+
+```text
+/knowledge list
+```
+
+### knowledge on / off
+
+开启或关闭知识库。关闭后不再注入知识提示词和索引知识文件。
+
+```text
+/knowledge on
+/knowledge off
+```
+
+<Note>
+  终端 CLI 中 `cow knowledge` 和 `cow knowledge list` 可用，但 `on|off` 仅支持在对话中使用（需实时生效）。
+</Note>
--- a/docs/cli/process.mdx
+++ b/docs/cli/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>
--- a/docs/cli/skill.mdx
+++ b/docs/cli/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` | 本地创建的技能 |
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -24,13 +24,13 @@
      },
      {
        "label": "GitHub",
-        "href": "https://github.com/zhayujie/chatgpt-on-wechat"
+        "href": "https://github.com/zhayujie/CowAgent"
      }
    ]
  },
  "footer": {
    "socials": {
-      "github": "https://github.com/zhayujie/chatgpt-on-wechat"
+      "github": "https://github.com/zhayujie/CowAgent"
    }
  },
  "navigation": {
@@ -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,9 @@
                "group": "技能系统",
                "pages": [
                  "skills/index",
-                  "skills/skill-creator"
-                ]
-              },
-              {
-                "group": "内置技能",
-                "pages": [
-                  "skills/image-vision",
-                  "skills/linkai-agent",
-                  "skills/web-fetch"
+                  "skills/install",
+                  "skills/create",
+                  "skills/hub"
                ]
              }
            ]
@@ -144,7 +141,20 @@
              {
                "group": "记忆系统",
                "pages": [
-                  "memory"
+                  "memory/index",
+                  "memory/context",
+                  "memory/deep-dream"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "知识",
+            "groups": [
+              {
+                "group": "知识库",
+                "pages": [
+                  "knowledge/index"
                ]
              }
            ]
@@ -167,6 +177,21 @@
              }
            ]
          },
+          {
+            "tab": "命令",
+            "groups": [
+              {
+                "group": "命令系统",
+                "pages": [
+                  "cli/index",
+                  "cli/process",
+                  "cli/skill",
+                  "cli/memory-knowledge",
+                  "cli/general"
+                ]
+              }
+            ]
+          },
          {
            "tab": "版本",
            "groups": [
@@ -174,6 +199,8 @@
                "group": "发布记录",
                "pages": [
                  "releases/overview",
+                  "releases/v2.0.6",
+                  "releases/v2.0.5",
                  "releases/v2.0.4",
                  "releases/v2.0.3",
                  "releases/v2.0.2",
@@ -254,14 +281,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,15 +303,9 @@
                "group": "Skills System",
                "pages": [
                  "en/skills/index",
-                  "en/skills/skill-creator"
-                ]
-              },
-              {
-                "group": "Built-in Skills",
-                "pages": [
-                  "en/skills/image-vision",
-                  "en/skills/linkai-agent",
-                  "en/skills/web-fetch"
+                  "en/skills/install",
+                  "en/skills/skill-creator",
+                  "en/skills/hub"
                ]
              }
            ]
@@ -292,7 +316,20 @@
              {
                "group": "Memory System",
                "pages": [
-                  "en/memory"
+                  "en/memory/index",
+                  "en/memory/context",
+                  "en/memory/deep-dream"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "Knowledge",
+            "groups": [
+              {
+                "group": "Knowledge Base",
+                "pages": [
+                  "en/knowledge/index"
                ]
              }
            ]
@@ -315,6 +352,21 @@
              }
            ]
          },
+          {
+            "tab": "CLI",
+            "groups": [
+              {
+                "group": "Command System",
+                "pages": [
+                  "en/cli/index",
+                  "en/cli/process",
+                  "en/cli/skill",
+                  "en/cli/memory-knowledge",
+                  "en/cli/chat"
+                ]
+              }
+            ]
+          },
          {
            "tab": "Releases",
            "groups": [
@@ -322,6 +374,8 @@
                "group": "Release Notes",
                "pages": [
                  "en/releases/overview",
+                  "en/releases/v2.0.6",
+                  "en/releases/v2.0.5",
                  "en/releases/v2.0.4",
                  "en/releases/v2.0.2",
                  "en/releases/v2.0.1",
@@ -403,14 +457,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 +478,9 @@
                "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",
+                  "ja/skills/hub"
                ]
              }
            ]
@@ -441,7 +491,20 @@
              {
                "group": "メモリシステム",
                "pages": [
-                  "ja/memory"
+                  "ja/memory/index",
+                  "ja/memory/context",
+                  "ja/memory/deep-dream"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "ナレッジ",
+            "groups": [
+              {
+                "group": "ナレッジベース",
+                "pages": [
+                  "ja/knowledge/index"
                ]
              }
            ]
@@ -464,6 +527,21 @@
              }
            ]
          },
+          {
+            "tab": "CLI",
+            "groups": [
+              {
+                "group": "コマンドシステム",
+                "pages": [
+                  "ja/cli/index",
+                  "ja/cli/process",
+                  "ja/cli/skill",
+                  "ja/cli/memory-knowledge",
+                  "ja/cli/general"
+                ]
+              }
+            ]
+          },
          {
            "tab": "リリース",
            "groups": [
@@ -471,6 +549,8 @@
                "group": "リリースノート",
                "pages": [
                  "ja/releases/overview",
+                  "ja/releases/v2.0.6",
+                  "ja/releases/v2.0.5",
                  "ja/releases/v2.0.4",
                  "ja/releases/v2.0.3",
                  "ja/releases/v2.0.2",
--- a/docs/en/README.md
+++ b/docs/en/README.md
@@ -1,18 +1,19 @@
 <p align="center"><img src="https://github.com/user-attachments/assets/eca9a9ec-8534-4615-9e0f-96c5ac1d10a3" alt="CowAgent" width="550" /></p>

 <p align="center">
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/chatgpt-on-wechat" alt="Latest release"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/chatgpt-on-wechat" alt="License: MIT"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat"><img src="https://img.shields.io/github/stars/zhayujie/chatgpt-on-wechat?style=flat-square" alt="Stars"></a> <br/>
-  [<a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/README.md">中文</a>] | [English] | [<a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/docs/ja/README.md">日本語</a>]
+  <a href="https://github.com/zhayujie/CowAgent/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/CowAgent" alt="Latest release"></a>
+  <a href="https://github.com/zhayujie/CowAgent/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/CowAgent" alt="License: MIT"></a>
+  <a href="https://github.com/zhayujie/CowAgent"><img src="https://img.shields.io/github/stars/zhayujie/CowAgent?style=flat-square" alt="Stars"></a> <br/>
+  [<a href="https://github.com/zhayujie/CowAgent/blob/master/README.md">中文</a>] | [English] | [<a href="https://github.com/zhayujie/CowAgent/blob/master/docs/ja/README.md">日本語</a>]
 </p>

-**CowAgent** is an AI super assistant powered by LLMs, capable of autonomous task planning, operating computers and external resources, creating and executing Skills, and continuously growing with long-term memory. It supports flexible model switching, handles text, voice, images, and files, and can be integrated into WeChat, Web, Feishu, DingTalk, WeCom Bot, WeCom App, and WeChat Official Account — running 7×24 hours on your personal computer or server.
+**CowAgent** is an AI super assistant powered by LLMs, capable of autonomous task planning, operating computers and external resources, creating and executing Skills, and continuously growing with long-term memory and a personal knowledge base. It supports flexible model switching, handles text, voice, images, and files, and can be integrated into WeChat, Web, Feishu, DingTalk, WeCom Bot, WeCom App, and WeChat Official Account — running 7×24 hours on your personal computer or server.

 <p align="center">
  <a href="https://cowagent.ai/">🌐 Website</a> &nbsp;·&nbsp;
  <a href="https://docs.cowagent.ai/en/intro/index">📖 Docs</a> &nbsp;·&nbsp;
  <a href="https://docs.cowagent.ai/en/guide/quick-start">🚀 Quick Start</a> &nbsp;·&nbsp;
+  <a href="https://skills.cowagent.ai/">🧩 Skill Hub</a> &nbsp;·&nbsp;
  <a href="https://link-ai.tech/cowagent/create">☁️ Try Online</a>
 </p>

@@ -20,13 +21,15 @@

 > 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.
- ✅ **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.
+- ✅ **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, daily memory, and Deep Dream distillation, with keyword and vector retrieval support.
+- ✅ **Personal Knowledge Base**: Automatically organizes structured knowledge with cross-references to build a knowledge graph, with web-based visualization and conversational management.
+- ✅ **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

@@ -40,17 +43,21 @@ Try online (no deployment needed): [CowAgent](https://link-ai.tech/cowagent/crea

 ## Changelog

-> **2026.02.27:** [v2.0.2](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.2) — Web console overhaul (streaming chat, model/skill/memory/channel/scheduler/log management), multi-channel concurrent running, session persistence, new models including Gemini 3.1 Pro / Claude 4.6 Sonnet / Qwen3.5 Plus.
+> **2026.04.14:** [v2.0.6](https://github.com/zhayujie/CowAgent/releases/tag/2.0.6) — Knowledge Base, Deep Dream Memory Distillation, Smart Context Compression, Web Console upgrades.

-> **2026.02.13:** [v2.0.1](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.1) — Built-in Web Search tool, smart context trimming, runtime info dynamic update, Windows compatibility, fixes for scheduler memory loss, Feishu connection issues, and more.
+> **2026.04.01:** [v2.0.5](https://github.com/zhayujie/CowAgent/releases/tag/2.0.5) — Cow CLI, Skill Hub open source, Browser tool, WeCom Bot QR scan, and more.

-> **2026.02.03:** [v2.0.0](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0) — Full upgrade to AI super assistant with multi-step task planning, long-term memory, built-in tools, Skills framework, new models, and optimized channels.
+> **2026.02.27:** [v2.0.2](https://github.com/zhayujie/CowAgent/releases/tag/2.0.2) — Web console overhaul (streaming chat, model/skill/memory/channel/scheduler/log management), multi-channel concurrent running, session persistence, new models including Gemini 3.1 Pro / Claude 4.6 Sonnet / Qwen3.5 Plus.

-> **2025.05.23:** [v1.7.6](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.6) — Web channel optimization, AgentMesh multi-agent plugin, Baidu TTS, claude-4-sonnet/opus support.
+> **2026.02.13:** [v2.0.1](https://github.com/zhayujie/CowAgent/releases/tag/2.0.1) — Built-in Web Search tool, smart context trimming, runtime info dynamic update, Windows compatibility, fixes for scheduler memory loss, Feishu connection issues, and more.

-> **2025.04.11:** [v1.7.5](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.5) — wechatferry protocol, DeepSeek model, Tencent Cloud voice, ModelScope and Gitee-AI support.
+> **2026.02.03:** [v2.0.0](https://github.com/zhayujie/CowAgent/releases/tag/2.0.0) — Full upgrade to AI super assistant with multi-step task planning, long-term memory, built-in tools, Skills framework, new models, and optimized channels.

-> **2024.12.13:** [v1.7.4](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.4) — Gemini 2.0 model, Web channel, memory leak fix.
+> **2025.05.23:** [v1.7.6](https://github.com/zhayujie/CowAgent/releases/tag/1.7.6) — Web channel optimization, AgentMesh multi-agent plugin, Baidu TTS, claude-4-sonnet/opus support.
+
+> **2025.04.11:** [v1.7.5](https://github.com/zhayujie/CowAgent/releases/tag/1.7.5) — wechatferry protocol, DeepSeek model, Tencent Cloud voice, ModelScope and Gitee-AI support.
+
+> **2024.12.13:** [v1.7.4](https://github.com/zhayujie/CowAgent/releases/tag/1.7.4) — Gemini 2.0 model, Web channel, memory leak fix.

 Full changelog: [Release Notes](https://docs.cowagent.ai/en/releases/overview)

@@ -60,21 +67,27 @@ 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/cli/index) to manage the service.

 ### Manual Installation

 **1. Clone the project**

 ```bash
-git clone https://github.com/zhayujie/chatgpt-on-wechat
-cd chatgpt-on-wechat/
+git clone https://github.com/zhayujie/CowAgent
+cd CowAgent/
 ```

 **2. Install dependencies**
@@ -84,7 +97,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/cli/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 +123,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
@@ -125,7 +168,7 @@ Supports mainstream model providers. Recommended models for Agent mode:
 | GLM | `glm-5-turbo` |
 | Kimi | `kimi-k2.5` |
 | Doubao | `doubao-seed-2-0-code-preview-260215` |
-| Qwen | `qwen3.5-plus` |
+| Qwen | `qwen3.6-plus` |
 | Claude | `claude-sonnet-4-6` |
 | Gemini | `gemini-3.1-pro-preview` |
 | OpenAI | `gpt-5.4` |
@@ -186,21 +229,22 @@ Multiple channels can be enabled simultaneously, separated by commas: `"channel_

 ## 🔗 Related Projects

+- [Cow Skill Hub](https://github.com/zhayujie/cow-skill-hub): Open skill marketplace for AI Agents — browse, search, install, and publish skills for CowAgent, OpenClaw, Claude Code, and more.
 - [bot-on-anything](https://github.com/zhayujie/bot-on-anything): Lightweight and highly extensible LLM application framework supporting Slack, Telegram, Discord, Gmail, and more.
 - [AgentMesh](https://github.com/MinimalFuture/AgentMesh): Open-source Multi-Agent framework for complex problem solving through agent team collaboration.

 ## 🔎 FAQ

-FAQs: <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
+FAQs: <https://github.com/zhayujie/CowAgent/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/CowAgent/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), or submit to [Skill Hub](https://skills.cowagent.ai/submit).

 ## ✉ Contact

-Welcome to submit PRs and Issues, and support the project with a 🌟 Star. For questions, check the [FAQ list](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) or search [Issues](https://github.com/zhayujie/chatgpt-on-wechat/issues).
+Welcome to submit PRs and Issues, and support the project with a 🌟 Star. For questions, check the [FAQ list](https://github.com/zhayujie/CowAgent/wiki/FAQs) or search [Issues](https://github.com/zhayujie/CowAgent/issues).

 ## 🌟 Contributors

-![cow contributors](https://contrib.rocks/image?repo=zhayujie/chatgpt-on-wechat&max=1000)
+![cow contributors](https://contrib.rocks/image?repo=zhayujie/CowAgent&max=1000)
--- a/docs/en/channels/web.mdx
+++ b/docs/en/channels/web.mdx
@@ -38,6 +38,16 @@ Supports streaming output with real-time display of the Agent's reasoning proces

 <img width="850" src="https://cdn.link-ai.tech/doc/20260227180120.png" />

+#### Multi-Session Management
+
+The chat interface supports multi-session management. All session records are persistently stored in a SQLite database:
+
+- **Session List**: Click the history icon on the left to expand/collapse the session list panel, with scroll-to-load support for all historical sessions
+- **AI-Generated Titles**: After the first exchange in a new session, the model is automatically called to generate a short summary title
+- **New Session**: Click the "New Chat" button at the top of the session list or the `+` button in the input area to create a new session
+- **Delete Session**: Click the delete button on a session item and confirm to permanently delete the session and all its messages
+- **Clear Context**: Click the clear button in the input area to insert a divider in the current session. Messages above the divider are still displayed but no longer included as context for the model
+
 ### Model Management

 Manage model configurations online without manually editing config files:
--- a/docs/en/cli/general.mdx
+++ b/docs/en/cli/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
+```
--- a/docs/en/cli/index.mdx
+++ b/docs/en/cli/index.mdx
@@ -0,0 +1,94 @@
+---
+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 ...)
+
+Memory & Knowledge:
+  memory    Memory distillation (dream)
+  knowledge View knowledge base stats and structure
+
+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.) |
+| `/memory dream [N]` | Manually trigger memory distillation (default 3 days, max 30) |
+| `/knowledge` | View knowledge base statistics |
+| `/knowledge list` | View knowledge base directory structure |
+| `/knowledge on\|off` | Enable or disable knowledge base |
+| `/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 | — | ✓ |
+| memory (subcommands) | ✗ | ✓ |
+| knowledge (subcommands) | ✓ | ✓ |
+| 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>
--- a/docs/en/cli/memory-knowledge.mdx
+++ b/docs/en/cli/memory-knowledge.mdx
@@ -0,0 +1,63 @@
+---
+title: Memory & Knowledge
+description: Memory distillation and knowledge base management commands
+---
+
+## memory
+
+Manage the Agent's long-term memory system.
+
+### memory dream
+
+Manually trigger memory distillation (Deep Dream) — consolidate recent daily memories into MEMORY.md and generate a dream diary.
+
+```text
+/memory dream [N]
+```
+
+- `N`: Consolidate the last N days of memory (default 3, max 30)
+- Runs asynchronously in the background; you'll be notified in chat when complete
+- Works without Agent initialization — can be used before the first conversation
+
+**Examples:**
+
+```text
+/memory dream       # Consolidate last 3 days
+/memory dream 7     # Consolidate last 7 days
+/memory dream 30    # Consolidate last 30 days (full)
+```
+
+On the Web console, the completion notification includes clickable links to view the updated MEMORY.md and dream diary.
+
+<Tip>
+  The system automatically runs distillation daily at 23:55 (lookback 1 day). Manual trigger is useful for consolidating historical memories after first deployment, or when you need an immediate memory update.
+</Tip>
+
+## knowledge
+
+View and manage the personal knowledge base. Shows statistics by default.
+
+```text
+/knowledge
+```
+
+### knowledge list
+
+View the knowledge base directory tree.
+
+```text
+/knowledge list
+```
+
+### knowledge on / off
+
+Enable or disable the knowledge base. When disabled, knowledge prompts and file indexing are not injected.
+
+```text
+/knowledge on
+/knowledge off
+```
+
+<Note>
+  In the terminal CLI, `cow knowledge` and `cow knowledge list` are available, but `on|off` is only supported in chat (requires runtime effect).
+</Note>
--- a/docs/en/cli/process.mdx
+++ b/docs/en/cli/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>
--- a/docs/en/cli/skill.mdx
+++ b/docs/en/cli/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 |
--- a/docs/en/guide/manual-install.mdx
+++ b/docs/en/guide/manual-install.mdx
@@ -8,12 +8,12 @@ description: Deploy CowAgent manually (source code / Docker)
 ### 1. Clone the project

 ```bash
-git clone https://github.com/zhayujie/chatgpt-on-wechat
-cd chatgpt-on-wechat/
+git clone https://github.com/zhayujie/CowAgent
+cd CowAgent/
 ```

 <Tip>
-  For network issues, use the mirror: https://gitee.com/zhayujie/chatgpt-on-wechat
+  For network issues, use the mirror: https://gitee.com/zhayujie/CowAgent
 </Tip>

 ### 2. Install dependencies
@@ -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
@@ -109,5 +141,5 @@ sudo docker logs -f chatgpt-on-wechat
 | `agent_max_steps` | Max decision steps per task | `15` |

 <Tip>
-  Full configuration options are in the project [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py).
+  Full configuration options are in the project [`config.py`](https://github.com/zhayujie/CowAgent/blob/master/config.py).
 </Tip>
--- a/docs/en/guide/quick-start.mdx
+++ b/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
+3. Clone project to `~/CowAgent`
+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/cli/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>
--- a/docs/en/intro/architecture.mdx
+++ b/docs/en/intro/architecture.mdx
@@ -11,14 +11,16 @@ CowAgent's architecture consists of the following core modules:

 <img src="https://cdn.link-ai.tech/doc/68ef7b212c6f791e0e74314b912149f9-sz_5847990.png" alt="CowAgent Architecture" />

-### Core Modules
-
 | Module | Description |
 | --- | --- |
-| **Channels** | Message channel layer for receiving and sending messages. Supports Web, Feishu, DingTalk, WeCom, WeChat Official Account, and more |
-| **Agent Core** | Agent engine including task planning, memory system, and skills engine |
-| **Tools** | Tool layer for Agent to access OS resources. 10+ built-in tools |
-| **Models** | Model layer with unified access to mainstream LLMs |
+| **Plan** | Understands user intent, decomposes complex tasks into multi-step plans, and iteratively invokes tools until the goal is achieved |
+| **Memory** | Automatically persists important information as core memory and daily memory, with hybrid keyword and vector retrieval for cross-session context continuity |
+| **Knowledge** | Organizes structured knowledge by topic. The Agent autonomously distills valuable information into Markdown pages, maintaining indexes and cross-references to build a growing knowledge network |
+| **Tools** | Core capability for Agent to access OS resources. 10+ built-in tools including file read/write, terminal, browser, scheduler, memory search, web search, and more |
+| **Skills** | Loads and manages Skills. Supports one-click installation from Skill Hub, GitHub, and more, or custom skill creation through conversation |
+| **Models** | Model layer with unified access to OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, and other mainstream LLMs |
+| **Channels** | Message channel layer for receiving and sending messages. Supports Web console, WeChat, Feishu, DingTalk, WeCom, WeChat Official Account, and more with a unified protocol |
+| **CLI** | Command-line system providing terminal commands (`cow`) and chat commands (`/`) for process management, skill installation, configuration, knowledge base management, and more |

 ## Agent Mode Workflow

@@ -28,7 +30,7 @@ When Agent mode is enabled, CowAgent runs as an autonomous agent with the follow
 2. **Understand Intent** — Analyze task requirements and context
 3. **Plan Task** — Break complex tasks into multiple steps
 4. **Invoke Tools** — Select and execute appropriate tools for each step
-5. **Update Memory** — Store important information in long-term memory
+5. **Update Memory & Knowledge** — Store important information in long-term memory and organize structured knowledge into the knowledge base
 6. **Return Result** — Send execution results back to the user

 ## Workspace Directory Structure
@@ -39,9 +41,12 @@ The Agent workspace is located at `~/cow` by default and stores system prompts,
 ~/cow/
 ├── system.md          # Agent system prompt
 ├── user.md            # User profile
+├── MEMORY.md          # Core memory
 ├── memory/            # Long-term memory storage
-│   ├── core.md        # Core memory
-│   └── daily/         # Daily memory
+│   └── YYYY-MM-DD.md  # Daily memory
+├── knowledge/         # Personal knowledge base
+│   ├── index.md       # Knowledge index
+│   └── <category>/    # Topic-based pages
 └── skills/            # Custom skills
    ├── skill-1/
    └── skill-2/
@@ -75,3 +80,4 @@ Configure Agent mode parameters in `config.json`:
 | `agent_max_context_tokens` | Max context tokens | `40000` |
 | `agent_max_context_turns` | Max context turns | `30` |
 | `agent_max_steps` | Max decision steps per task | `15` |
+| `knowledge` | Enable personal knowledge base | `true` |
--- a/docs/en/intro/features.mdx
+++ b/docs/en/intro/features.mdx
@@ -1,27 +1,46 @@
 ---
 title: Features
-description: CowAgent long-term memory, task planning, and skills system in detail
+description: CowAgent long-term memory, task planning, skills system, CLI commands, and browser tool in detail
 ---

 ## 1. Long-term Memory

-The memory system enables the Agent to remember important information over time. The Agent proactively stores information when users share preferences, decisions, or key facts, and automatically extracts summaries when conversations reach a certain length. Memory is divided into core memory and daily memory, with hybrid retrieval supporting both keyword search and vector search.
+The memory system enables the Agent to remember important information over time, using a three-tier memory flow: conversation context (short-term) → daily memory (mid-term) → MEMORY.md (long-term), forming a complete memory lifecycle.

 On first launch, the Agent proactively asks the user for key information and records it in the workspace (default `~/cow`) — including agent settings, user identity, and memory files.

-In subsequent long-term conversations, the Agent intelligently stores or retrieves memory as needed, continuously updating its own settings, user preferences, and memory files, summarizing experiences and lessons learned — truly achieving autonomous thinking and continuous growth.
+In subsequent long-term conversations, the Agent intelligently stores or retrieves memory as needed, continuously updating its own settings, user preferences, and memory files. **Deep Dream** distillation runs daily, consolidating scattered daily memories into refined long-term memory and generating a narrative-style dream diary.

 <Frame>
  <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
 </Frame>

-## 2. Task Planning and Tool Use
+See [Long-term Memory](/en/memory) and [Deep Dream](/en/memory/deep-dream) for details.
+
+## 2. Personal Knowledge Base
+
+> The knowledge base system enables the Agent to continuously accumulate and organize structured knowledge. Unlike memory which records along a timeline, the knowledge base is organized by topics, transforming articles, conversation insights, and learning materials into interconnected Markdown pages that form a continuously growing knowledge network.
+
+The Agent automatically organizes valuable information from conversations into knowledge pages, maintaining cross-references and indexes. The Web console provides document browsing and knowledge graph visualization. Knowledge is stored in `~/cow/knowledge/` within the workspace.
+
+- **Auto-organization**: The Agent autonomously extracts and organizes structured knowledge during conversations, maintaining indexes and cross-references
+- **Knowledge graph**: Automatically builds a knowledge graph from cross-references between pages, with interactive graph visualization in the Web console
+- **Chat integration**: Knowledge document links referenced in Agent replies can be clicked directly in the Web console for viewing
+- **CLI management**: Use `/knowledge` commands to view stats, browse directory, and toggle the feature with `/knowledge on|off`
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260413105435.png" width="800" />
+</Frame>
+
+See [Personal Knowledge Base](/en/knowledge) for details.
+
+## 3. Task Planning and Tool Use

 Tools are the core of how the Agent accesses operating system resources. The Agent intelligently selects and invokes tools based on task requirements, performing file read/write, command execution, scheduled tasks, and more. Built-in tools are implemented in the project's `agent/tools/` directory.

-**Key tools:** file read/write/edit, Bash terminal, file send, scheduler, memory search, web search, environment config, and more.
+**Key tools:** file read/write/edit, Bash terminal, browser, file send, scheduler, memory search, web search, environment config, and more.

-### 2.1 Terminal and File Access
+### 3.1 Terminal and File Access

 Access to the OS terminal and file system is the most fundamental and core capability. Many other tools and skills build on top of this. Users can interact with the Agent from a mobile device to operate resources on their personal computer or server:

@@ -29,15 +48,15 @@ Access to the OS terminal and file system is the most fundamental and core capab
  <img src="https://cdn.link-ai.tech/doc/20260202181130.png" width="800" />
 </Frame>

-### 2.2 Programming Capability
+### 3.2 Programming Capability

 Combining programming and system access, the Agent can execute the complete **Vibecoding workflow** — from information search, asset generation, coding, testing, deployment, Nginx configuration, to publishing — all triggered by a single command from your phone:

 <Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260203121008.png" width="800" />
+  <img src="https://cdn.link-ai.tech/doc/20260318211018.png" width="800" />
 </Frame>

-### 2.3 Scheduled Tasks
+### 3.3 Scheduled Tasks

 The `scheduler` tool enables dynamic scheduled tasks, supporting **one-time tasks, fixed intervals, and Cron expressions**. Tasks can be triggered as either a **fixed message send** or an **Agent dynamic task** execution:

@@ -45,7 +64,15 @@ The `scheduler` tool enables dynamic scheduled tasks, supporting **one-time task
  <img src="https://cdn.link-ai.tech/doc/20260202195402.png" width="800" />
 </Frame>

-### 2.4 Environment Variable Management
+### 3.4 Browser
+
+The built-in `browser` tool allows the Agent to control a Chromium browser to visit web pages, fill forms, click elements, and take screenshots, with support for dynamic JS-rendered pages. Run `cow install-browser` to install with one command, automatically adapting to server (headless) and desktop environments:
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260401110103.png" width="800" />
+</Frame>
+
+### 3.5 Environment Variable Management

 Secrets required by skills are stored in an environment variable file, managed by the `env_config` tool. You can update secrets through conversation, with built-in security protection and desensitization:

@@ -53,14 +80,17 @@ Secrets required by skills are stored in an environment variable file, managed b
  <img src="https://cdn.link-ai.tech/doc/20260202234939.png" width="800" />
 </Frame>

-## 3. Skills System
+## 4. Skills System

 The Skills system provides infinite extensibility for the Agent. Each Skill consists of a description file, execution scripts (optional), and resources (optional), describing how to complete specific types of tasks. Skills allow the Agent to follow instructions for complex workflows, invoke tools, or integrate third-party systems.

+- **[Skill Hub](https://skills.cowagent.ai/):** An open skill marketplace featuring official, community, and third-party skills. Install with one command.
 - **Built-in skills:** Located in the project's `skills/` directory, including skill creator, image recognition, LinkAI agent, web fetch, and more. Built-in skills are automatically enabled based on dependency conditions (API keys, system commands, etc.).
 - **Custom skills:** Created by users through conversation, stored in the workspace (`~/cow/skills/`), capable of implementing any complex business process or third-party integration.

-### 3.1 Creating Skills
+Install skills: `/skill install <name>` or `cow skill install <name>`, supporting Skill Hub, GitHub, ClawHub, URL, and more.
+
+### 4.1 Creating Skills

 The `skill-creator` skill enables rapid skill creation through conversation. You can ask the Agent to codify a workflow as a skill, or send any API documentation and examples for the Agent to complete the integration directly:

@@ -68,7 +98,7 @@ The `skill-creator` skill enables rapid skill creation through conversation. You
  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
 </Frame>

-### 3.2 Web Search and Image Recognition
+### 4.2 Web Search and Image Recognition

 - **Web search:** Built-in `web_search` tool, supports multiple search engines. Configure `BOCHA_API_KEY` or `LINKAI_API_KEY` to enable.
 - **Image recognition:** Built-in `openai-image-vision` skill, supports `gpt-4.1-mini`, `gpt-4.1`, and other models. Requires `OPENAI_API_KEY`.
@@ -77,29 +107,33 @@ The `skill-creator` skill enables rapid skill creation through conversation. You
  <img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
 </Frame>

-### 3.3 Third-party Knowledge Bases and Plugins
+### 4.3 Skill Hub

-The `linkai-agent` skill makes all agents on [LinkAI](https://link-ai.tech/) available as Skills for the Agent, enabling multi-agent decision making.
+Visit [skills.cowagent.ai](https://skills.cowagent.ai/) to browse all available skills, or use commands in conversation:

-Configuration: set `LINKAI_API_KEY` via `env_config`, then add agent descriptions in `skills/linkai-agent/config.json`:
-
-```json
-{
-  "apps": [
-    {
-      "app_code": "G7z6vKwp",
-      "app_name": "LinkAI Customer Support",
-      "app_description": "Select only when the user needs help with LinkAI platform questions"
-    },
-    {
-      "app_code": "SFY5x7JR",
-      "app_name": "Content Creator",
-      "app_description": "Use only when the user needs to create images or videos"
-    }
-  ]
-}
+```text
+/skill list --remote          # Browse Skill Hub
+/skill search <keyword>       # Search skills
+/skill install <name>          # Install with one command
 ```

-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
-</Frame>
+Also supports installing skills from GitHub, ClawHub, LinkAI, and other third-party platforms. See [Install Skills](/en/skills/install) for details.
+
+<img src="https://cdn.link-ai.tech/doc/20260401110103.png" width="750" />
+
+## 5. CLI Command System
+
+CowAgent provides two command interaction methods, covering service management, skill installation, configuration, and more:
+
+- **Terminal CLI:** Run `cow <command>` in the system terminal, supporting `start`, `stop`, `restart`, `update`, `status`, `logs`, `skill`, etc.
+- **Chat commands:** Type `/<command>` in conversation. The Web console shows a command menu when you type `/`.
+
+```bash
+cow start              # Start service
+cow stop               # Stop service
+cow update             # Update and restart
+cow skill install pptx # Install a skill
+cow install-browser    # Install browser tool
+```
+
+See [Command Overview](https://docs.cowagent.ai/en/cli) for details.
--- a/docs/en/intro/index.mdx
+++ b/docs/en/intro/index.mdx
@@ -9,8 +9,8 @@ description: CowAgent - AI Super Assistant powered by LLMs

 CowAgent can proactively think and plan tasks, operate computers and external resources, create and execute Skills, and continuously grow with long-term memory. It supports flexible switching between multiple models, handles text, voice, images, files and other multimodal messages, and can be integrated into WeChat, web, Feishu, DingTalk, WeCom, and WeChat Official Account. It runs 7x24 hours on your personal computer or server.

-<Card title="GitHub" icon="github" href="https://github.com/zhayujie/chatgpt-on-wechat">
-  github.com/zhayujie/chatgpt-on-wechat
+<Card title="GitHub" icon="github" href="https://github.com/zhayujie/CowAgent">
+  github.com/zhayujie/CowAgent
 </Card>

 ## Core Capabilities
@@ -20,7 +20,10 @@ CowAgent can proactively think and plan tasks, operate computers and external re
    Understands complex tasks and autonomously plans execution, continuously thinking and invoking tools until goals are achieved. Supports accessing file systems, terminals, browsers, schedulers, and other system resources through tools.
  </Card>
  <Card title="Long-term Memory" icon="database" href="/en/memory">
-    Automatically persists conversation memory to local files and databases, including core memory and daily memory, with keyword and vector retrieval support.
+    Three-tier memory flow (context → daily memory → global memory) with daily Deep Dream distillation, keyword and vector retrieval support.
+  </Card>
+  <Card title="Knowledge Base" icon="book" href="/en/knowledge">
+    Automatically organizes structured knowledge with knowledge graph visualization, building a continuously growing knowledge network through cross-references.
  </Card>
  <Card title="Skills System" icon="puzzle-piece" href="/en/skills/index">
    Implements a Skills creation and execution engine with built-in skills, and supports custom Skills development through natural language conversation.
@@ -28,6 +31,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/cli/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 +49,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.

@@ -57,7 +75,7 @@ By default, the Web service starts after running. Access `http://localhost:9899/

 ## Disclaimer

-1. This project follows the [MIT License](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/LICENSE) and is intended for technical research and learning. Users must comply with local laws, regulations, policies, and corporate bylaws. Any illegal or rights-infringing use is prohibited.
+1. This project follows the [MIT License](https://github.com/zhayujie/CowAgent/blob/master/LICENSE) and is intended for technical research and learning. Users must comply with local laws, regulations, policies, and corporate bylaws. Any illegal or rights-infringing use is prohibited.
 2. Agent mode consumes more tokens than normal chat mode. Choose models based on effectiveness and cost. Agent has access to the host operating system — deploy with caution.
 3. CowAgent focuses on open-source development and does not participate in, authorize, or issue any cryptocurrency.

--- a/docs/en/knowledge/index.mdx
+++ b/docs/en/knowledge/index.mdx
@@ -0,0 +1,89 @@
+---
+title: Personal Knowledge Base
+description: CowAgent personal knowledge base — structured knowledge accumulation, automatic organization, and knowledge graph
+---
+
+The personal knowledge base is the Agent's long-term structured knowledge store, saved in the `knowledge/` directory within the workspace. Unlike memory, which is organized by timeline, the knowledge base organizes content by topic — articles, conversation insights, and learning materials are structured into interlinked Markdown pages, forming a continuously growing knowledge network.
+
+## Core Concepts
+
+### Knowledge vs Memory
+
+| Dimension | Knowledge Base (knowledge/) | Long-term Memory (memory/) |
+| --- | --- | --- |
+| Organization | By topic, interlinked | By timeline, dated files |
+| Writing | Agent actively structures content | Auto-summarized on context trimming |
+| Content | Refined, structured knowledge | Raw conversation summaries |
+| Use cases | Study notes, tech docs, project knowledge | Conversation history, event records |
+
+### Directory Structure
+
+```
+~/cow/knowledge/
+├── index.md          # Knowledge index, entry point for all pages
+├── log.md            # Change log, records each write
+├── concepts/         # Conceptual knowledge
+│   └── machine-learning.md
+├── entities/         # Entity knowledge (people, orgs, tools)
+│   └── openai.md
+└── sources/          # Source knowledge (articles, papers)
+    └── llm-wiki.md
+```
+
+The directory structure is flexible — the Agent automatically creates appropriate category directories based on actual content. Users can also customize the organization.
+
+## Automatic Organization
+
+Knowledge writing is an autonomous Agent behavior, triggered in these scenarios:
+
+- **User shares an article or document** — The Agent automatically extracts key information and creates a structured knowledge page
+- **Conversation produces valuable conclusions** — The Agent organizes insights into knowledge pages and links them to existing knowledge
+- **User explicitly requests organization** — Users can guide the Agent to organize and update knowledge through conversation
+
+Each knowledge page includes cross-reference links to related pages, gradually building a knowledge graph.
+
+<Frame>
+  <img src="https://gist.github.com/user-attachments/assets/3ce92f78-1863-4820-8fa8-660c0f2b7f09" alt="Conversational knowledge ingest" />
+</Frame>
+
+## Knowledge Retrieval
+
+The Agent can retrieve knowledge during conversation through:
+
+- **Index lookup** — Quickly locate relevant pages via `knowledge/index.md`
+- **Semantic search** — Search knowledge content via the `memory_search` tool
+- **Direct read** — Read specific knowledge files via the `memory_get` tool
+
+## Web Console
+
+The web console provides a dedicated "Knowledge" module with:
+
+- **Document browsing** — Tree-style directory structure, searchable and collapsible, click to view content
+- **Knowledge graph** — Interactive graph visualizing relationships between knowledge pages
+- **Chat integration** — Knowledge document links referenced in Agent replies are clickable for direct navigation
+
+<Frame>
+  <img src="https://gist.github.com/user-attachments/assets/b7b9d6be-0ac1-4c65-803b-2c6b36bd59a7" alt="Knowledge document browsing" />
+</Frame>
+
+<Frame>
+  <img src="https://gist.github.com/user-attachments/assets/44ae68ca-96cc-40b9-ab33-cdbec34c2379" alt="Knowledge graph visualization" />
+</Frame>
+
+## CLI Commands
+
+Manage the knowledge base with the `/knowledge` command:
+
+| Command | Description |
+| --- | --- |
+| `/knowledge` | Show knowledge base statistics |
+| `/knowledge list` | Display file directory as a tree |
+| `/knowledge on` | Enable the knowledge base feature |
+| `/knowledge off` | Disable the knowledge base feature |
+
+## Configuration
+
+| Parameter | Description | Default |
+| --- | --- | --- |
+| `knowledge` | Whether to enable the personal knowledge base | `true` |
+| `agent_workspace` | Workspace path; knowledge is stored under the `knowledge/` subdirectory | `~/cow` |
--- a/docs/en/memory.mdx
+++ b/docs/en/memory.mdx
@@ -1,66 +0,0 @@
---
-title: Memory
-description: CowAgent long-term memory system
---
-
-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.
-
-## 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.
-
-### 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.
-
-## Memory Writing
-
-The Agent automatically persists conversation content to daily 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
- **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.
-
-## First Launch
-
-On first launch, the Agent will proactively ask the user for key information and save it to the workspace (default `~/cow`):
-
-| File | Description |
-| --- | --- |
-| `system.md` | Agent system prompt and behavior settings |
-| `user.md` | User identity information and preferences |
-| `MEMORY.md` | Core memory (long-term) |
-| `memory/YYYY-MM-DD.md` | Daily memory (created on demand) |
-
-<Frame>
-  <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` |
--- a/docs/en/memory/context.mdx
+++ b/docs/en/memory/context.mdx
@@ -0,0 +1,81 @@
+---
+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**
+- Once the LLM summary is ready, it is also **injected into the first user message** of the retained context, helping the model maintain conversational continuity
+- Summary injection runs asynchronously in the background and takes effect from the next turn onward
+
+### 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 written to memory and a context summary injected
+
+### 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>
--- a/docs/en/memory/deep-dream.mdx
+++ b/docs/en/memory/deep-dream.mdx
@@ -0,0 +1,90 @@
+---
+title: Deep Dream
+description: Deep Dream — automatic distillation from conversations to permanent memory
+---
+
+Deep Dream is the core consolidation mechanism of CowAgent's memory system, responsible for distilling scattered daily memories into refined long-term memory and generating dream diaries.
+
+## Memory Flow
+
+CowAgent's memory progresses through three stages from short-term to long-term:
+
+```
+Conversation context (short-term) → Daily memory (mid-term) → MEMORY.md (long-term)
+```
+
+### 1. Conversation → Daily Memory
+
+When conversation context is trimmed or during the daily scheduled summary, the system uses LLM to summarize conversation content into key events, writing them to the daily memory file `memory/YYYY-MM-DD.md`.
+
+Triggers:
+- **Context trimming** — Trimmed content is summarized when turn or token limits are exceeded
+- **Daily schedule** — Automatically triggered at 23:55
+- **API overflow** — Emergency save of current conversation summary
+
+### 2. Daily Memory → MEMORY.md (Distillation)
+
+After the daily summary completes, Deep Dream automatically runs distillation:
+
+1. **Read materials** — Current `MEMORY.md` + today's daily memory
+2. **LLM distillation** — Deduplicate, merge, prune, extract new information
+3. **Overwrite MEMORY.md** — Output the refined long-term memory
+4. **Generate dream diary** — Record discoveries and insights from the consolidation
+
+### 3. Role of MEMORY.md
+
+`MEMORY.md` is injected into the system prompt for every conversation, keeping the Agent aware of user preferences, decisions, and key facts. Therefore it must stay concise — Deep Dream targets approximately 30 entries or fewer.
+
+## Distillation Rules
+
+Deep Dream follows these consolidation rules:
+
+| Operation | Description |
+| --- | --- |
+| **Merge & refine** | Combine similar entries into single high-density statements |
+| **Extract new** | Pull preferences, decisions, people, experiences from daily memory |
+| **Conflict update** | When new info contradicts old entries, newer info takes precedence |
+| **Clean invalid** | Remove temporary records, blank entries, formatting artifacts |
+| **Remove redundancy** | Delete old entries already covered by more refined statements |
+
+## Dream Diary
+
+Each distillation generates a dream diary saved at `memory/dreams/YYYY-MM-DD.md`, written in a narrative style recording:
+
+- Duplications or contradictions found
+- New insights extracted from daily memory
+- Cleanups and optimizations performed
+- Overall observations
+
+Dream diaries can be viewed in the Web console under "Memory → Dream Diary" tab.
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260414110032.png" width="800" />
+</Frame>
+
+## Manual Trigger
+
+In addition to the automatic daily run, you can manually trigger distillation in chat:
+
+```text
+/memory dream [N]
+```
+
+- `N`: Consolidate the last N days of memory (default 3, max 30)
+- Runs asynchronously in the background; you'll be notified in chat when complete
+- Web notifications include clickable links to view MEMORY.md and dream diary
+- Works without Agent initialization — can be used before the first conversation
+
+<Tip>
+  After first deployment, it's recommended to run `/memory dream 30` once to distill all historical daily memories into MEMORY.md.
+</Tip>
+
+## Safety Mechanisms
+
+| Mechanism | Description |
+| --- | --- |
+| **Skip on no content** | Distillation skipped when no daily memory exists, avoiding empty overwrites |
+| **Input dedup** | In scheduled tasks, automatically skipped when input materials haven't changed |
+| **Async execution** | Distillation runs in a background thread, never blocking conversation |
+| **Sequential guarantee** | In scheduled tasks, daily flush completes before distillation starts |
+| **No fabrication** | Prompt explicitly constrains consolidation to existing materials only |
--- a/docs/en/memory/index.mdx
+++ b/docs/en/memory/index.mdx
@@ -0,0 +1,64 @@
+---
+title: Long-term Memory
+description: CowAgent long-term memory system — file persistence, automatic writing, and hybrid retrieval
+---
+
+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. 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.
+
+### Dream Diary (memory/dreams/YYYY-MM-DD.md)
+
+A byproduct of the Deep Dream (memory distillation) process, recording discoveries, deduplication operations, and new insights from each consolidation. Stored in `~/cow/memory/dreams/` directory, named by date.
+
+## Automatic Writing
+
+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, and the discarded content is summarized by LLM into key information and written to the daily memory file. The summary is also asynchronously injected into the retained context for conversational continuity
+- **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)
+- **[Deep Dream (memory distillation)](/en/memory/deep-dream)** — Runs automatically after the daily summary, distilling daily memories into MEMORY.md and generating a dream diary
+- **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`):
+
+| File | Description |
+| --- | --- |
+| `system.md` | Agent system prompt and behavior settings |
+| `user.md` | User identity information and preferences |
+| `MEMORY.md` | Core memory (long-term) |
+| `memory/YYYY-MM-DD.md` | Daily memory (created on demand) |
+| `memory/dreams/YYYY-MM-DD.md` | Dream diary (auto-generated by Deep Dream) |
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
+</Frame>
+
+## Configuration
+
+| Parameter | Description | Default |
+| --- | --- | --- |
+| `agent_workspace` | Workspace path, memory files stored under this directory | `~/cow` |
+| `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` |
--- a/docs/en/models/index.mdx
+++ b/docs/en/models/index.mdx
@@ -6,7 +6,7 @@ description: Supported models and recommended choices for CowAgent
 CowAgent supports mainstream LLMs from domestic and international providers. Model interfaces are implemented in the project's `models/` directory.

 <Note>
-  For Agent mode, the following models are recommended based on quality and cost: MiniMax-M2.7, glm-5-turbo, kimi-k2.5, qwen3.5-plus, claude-sonnet-4-6, gemini-3.1-pro-preview
+  For Agent mode, the following models are recommended based on quality and cost: MiniMax-M2.7, glm-5-turbo, kimi-k2.5, qwen3.6-plus, claude-sonnet-4-6, gemini-3.1-pro-preview
 </Note>

 ## Configuration
@@ -25,7 +25,7 @@ You can also use the [LinkAI](https://link-ai.tech) platform interface to flexib
    glm-5-turbo, glm-5 and other series models
  </Card>
  <Card title="Qwen (Tongyi Qianwen)" href="/en/models/qwen">
-    qwen3.5-plus, qwen3-max and more
+    qwen3.6-plus, qwen3-max and more
  </Card>
  <Card title="Kimi" href="/en/models/kimi">
    kimi-k2.5, kimi-k2 and more
@@ -51,5 +51,5 @@ You can also use the [LinkAI](https://link-ai.tech) platform interface to flexib
 </CardGroup>

 <Tip>
-  For a full list of model names, refer to the project's [`common/const.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py) file.
+  For a full list of model names, refer to the project's [`common/const.py`](https://github.com/zhayujie/CowAgent/blob/master/common/const.py) file.
 </Tip>
--- a/docs/en/models/qwen.mdx
+++ b/docs/en/models/qwen.mdx
@@ -5,14 +5,14 @@ description: Tongyi Qianwen model configuration

 ```json
 {
-  "model": "qwen3.5-plus",
+  "model": "qwen3.6-plus",
  "dashscope_api_key": "YOUR_API_KEY"
 }
 ```

 | Parameter | Description |
 | --- | --- |
-| `model` | Options include `qwen3.5-plus`, `qwen3-max`, `qwen-max`, `qwen-plus`, `qwen-turbo`, `qwq-plus`, etc. |
+| `model` | Options include `qwen3.6-plus`, `qwen3.5-plus`, `qwen3-max`, `qwen-max`, `qwen-plus`, `qwen-turbo`, `qwq-plus`, etc. |
 | `dashscope_api_key` | Create at [Bailian Console](https://bailian.console.aliyun.com/?tab=model#/api-key). See [official docs](https://bailian.console.aliyun.com/?tab=api#/api) |

 OpenAI-compatible configuration is also supported:
@@ -20,7 +20,7 @@ OpenAI-compatible configuration is also supported:
 ```json
 {
  "bot_type": "openai",
-  "model": "qwen3.5-plus",
+  "model": "qwen3.6-plus",
  "open_ai_api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1",
  "open_ai_api_key": "YOUR_API_KEY"
 }
--- a/docs/en/releases/overview.mdx
+++ b/docs/en/releases/overview.mdx
@@ -5,6 +5,8 @@ description: CowAgent version history

 | Version | Date | Description |
 | --- | --- | --- |
+| [2.0.6](/en/releases/v2.0.6) | 2026.04.14 | Knowledge Base, Deep Dream Memory Distillation, Smart Context Compression, Web Console upgrades |
+| [2.0.5](/en/releases/v2.0.5) | 2026.04.01 | Cow CLI, Skill Hub open source, Browser tool, WeCom Bot QR scan, and more |
 | [2.0.4](/en/releases/v2.0.4) | 2026.03.22 | Personal WeChat channel, new model support, Japanese docs, script refactoring and bug fixes |
 | [2.0.2](/en/releases/v2.0.2) | 2026.02.27 | Web Console upgrade, multi-channel concurrency, session persistence |
 | [2.0.1](/en/releases/v2.0.1) | 2026.02.27 | Built-in Web Search tool, smart context management, multiple fixes |
@@ -21,4 +23,4 @@ description: CowAgent version history
 | 1.5.0 | 2023.11.10 | gpt-4-turbo, dall-e-3, tts multimodal |
 | 1.0.0 | 2022.12.12 | Project created, first ChatGPT integration |

-See [GitHub Releases](https://github.com/zhayujie/chatgpt-on-wechat/releases) for full history.
+See [GitHub Releases](https://github.com/zhayujie/CowAgent/releases) for full history.
--- a/docs/en/releases/v2.0.0.mdx
+++ b/docs/en/releases/v2.0.0.mdx
@@ -5,7 +5,7 @@ description: CowAgent 2.0 - Full upgrade from chatbot to AI super assistant

 CowAgent 2.0 is a comprehensive upgrade from a chatbot to an **AI super assistant** — capable of autonomous thinking and task planning, long-term memory, operating computers, and creating and executing skills.

-**Release Date**: 2026.02.03 | [GitHub Release](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)
+**Release Date**: 2026.02.03 | [GitHub Release](https://github.com/zhayujie/CowAgent/releases/tag/2.0.0)

 ## Key Updates

@@ -60,4 +60,4 @@ CowAgent 2.0 is a comprehensive upgrade from a chatbot to an **AI super assistan

 ## Contributing

-Welcome to [submit feedback](https://github.com/zhayujie/chatgpt-on-wechat/issues) and [contribute code](https://github.com/zhayujie/chatgpt-on-wechat/pulls).
+Welcome to [submit feedback](https://github.com/zhayujie/CowAgent/issues) and [contribute code](https://github.com/zhayujie/CowAgent/pulls).
--- a/docs/en/releases/v2.0.1.mdx
+++ b/docs/en/releases/v2.0.1.mdx
@@ -3,34 +3,34 @@ title: v2.0.1
 description: CowAgent 2.0.1 - Built-in Web Search, smart context management, multiple fixes
 ---

-**Release Date**: 2026.02.27 | [Full Changelog](https://github.com/zhayujie/chatgpt-on-wechat/compare/2.0.0..2.0.1)
+**Release Date**: 2026.02.27 | [Full Changelog](https://github.com/zhayujie/CowAgent/compare/2.0.0..2.0.1)

 ## New Features

- **Built-in Web Search tool**: Integrated web search as a built-in Agent tool, reducing decision cost ([4f0ea5d](https://github.com/zhayujie/chatgpt-on-wechat/commit/4f0ea5d7568d61db91ff69c91c429e785fd1b1c2))
- **Claude Opus 4.6 model support**: Added support for Claude Opus 4.6 model ([#2661](https://github.com/zhayujie/chatgpt-on-wechat/pull/2661))
- **WeCom image recognition**: Support image message recognition in WeCom channel ([#2667](https://github.com/zhayujie/chatgpt-on-wechat/pull/2667))
+- **Built-in Web Search tool**: Integrated web search as a built-in Agent tool, reducing decision cost ([4f0ea5d](https://github.com/zhayujie/CowAgent/commit/4f0ea5d7568d61db91ff69c91c429e785fd1b1c2))
+- **Claude Opus 4.6 model support**: Added support for Claude Opus 4.6 model ([#2661](https://github.com/zhayujie/CowAgent/pull/2661))
+- **WeCom image recognition**: Support image message recognition in WeCom channel ([#2667](https://github.com/zhayujie/CowAgent/pull/2667))

 ## Improvements

- **Smart context management**: Resolved chat context overflow with intelligent context trimming strategy to prevent token limits ([cea7fb7](https://github.com/zhayujie/chatgpt-on-wechat/commit/cea7fb7490c53454602bf05955a0e9f059bcf0fd), [8acf2db](https://github.com/zhayujie/chatgpt-on-wechat/commit/8acf2dbdfe713b84ad74b761b7f86674b1c1904d)) [#2663](https://github.com/zhayujie/chatgpt-on-wechat/issues/2663)
- **Runtime info dynamic update**: Automatic update of timestamps and other runtime info in system prompts via dynamic functions ([#2655](https://github.com/zhayujie/chatgpt-on-wechat/pull/2655), [#2657](https://github.com/zhayujie/chatgpt-on-wechat/pull/2657))
- **Skill prompt optimization**: Improved Skill system prompt generation, simplified tool descriptions for better Agent performance ([6c21833](https://github.com/zhayujie/chatgpt-on-wechat/commit/6c218331b1f1208ea8be6bf226936d3b556ade3e))
- **GLM custom API Base URL**: Support custom API Base URL for GLM models ([#2660](https://github.com/zhayujie/chatgpt-on-wechat/pull/2660))
- **Startup script optimization**: Improved `run.sh` script interaction and configuration flow ([#2656](https://github.com/zhayujie/chatgpt-on-wechat/pull/2656))
- **Decision step logging**: Added Agent decision step logging for debugging ([cb303e6](https://github.com/zhayujie/chatgpt-on-wechat/commit/cb303e6109c50c8dfef1f5e6c1ec47223bf3cd11))
+- **Smart context management**: Resolved chat context overflow with intelligent context trimming strategy to prevent token limits ([cea7fb7](https://github.com/zhayujie/CowAgent/commit/cea7fb7490c53454602bf05955a0e9f059bcf0fd), [8acf2db](https://github.com/zhayujie/CowAgent/commit/8acf2dbdfe713b84ad74b761b7f86674b1c1904d)) [#2663](https://github.com/zhayujie/CowAgent/issues/2663)
+- **Runtime info dynamic update**: Automatic update of timestamps and other runtime info in system prompts via dynamic functions ([#2655](https://github.com/zhayujie/CowAgent/pull/2655), [#2657](https://github.com/zhayujie/CowAgent/pull/2657))
+- **Skill prompt optimization**: Improved Skill system prompt generation, simplified tool descriptions for better Agent performance ([6c21833](https://github.com/zhayujie/CowAgent/commit/6c218331b1f1208ea8be6bf226936d3b556ade3e))
+- **GLM custom API Base URL**: Support custom API Base URL for GLM models ([#2660](https://github.com/zhayujie/CowAgent/pull/2660))
+- **Startup script optimization**: Improved `run.sh` script interaction and configuration flow ([#2656](https://github.com/zhayujie/CowAgent/pull/2656))
+- **Decision step logging**: Added Agent decision step logging for debugging ([cb303e6](https://github.com/zhayujie/CowAgent/commit/cb303e6109c50c8dfef1f5e6c1ec47223bf3cd11))

 ## Bug Fixes

- **Scheduler memory loss**: Fixed memory loss caused by Scheduler dispatcher ([a77a874](https://github.com/zhayujie/chatgpt-on-wechat/commit/a77a8741b500a408c6f5c8868856fb4b018fe9db))
- **Empty tool calls & long results**: Fixed handling of empty tool calls and excessively long tool results ([0542700](https://github.com/zhayujie/chatgpt-on-wechat/commit/0542700f9091ebb08c1a56103b0f0f45f24aa621))
- **OpenAI Function Call**: Fixed function call compatibility with OpenAI models ([158c87a](https://github.com/zhayujie/chatgpt-on-wechat/commit/158c87ab8b05bae054cc1b4eacdbb64fc1062ba9))
- **Claude tool name field**: Removed extraneous tool name field from Claude model responses ([eec10cb](https://github.com/zhayujie/chatgpt-on-wechat/commit/eec10cb5db6a3d5bc12ef606606532237d2c5f6e))
- **MiniMax reasoning**: Optimized MiniMax model reasoning content handling, hidden thinking process output ([c72cda3](https://github.com/zhayujie/chatgpt-on-wechat/commit/c72cda33864bd1542012ee6e0a8bd8c6c88cb5ed), [72b1cac](https://github.com/zhayujie/chatgpt-on-wechat/commit/72b1cacea1ba0d1f3dedacbab2e088e98fd7e172))
- **GLM thinking process**: Hidden GLM model thinking process display ([72b1cac](https://github.com/zhayujie/chatgpt-on-wechat/commit/72b1cacea1ba0d1f3dedacbab2e088e98fd7e172))
- **Feishu connection & SSL**: Fixed Feishu channel SSL certificate errors and connection issues ([229b14b](https://github.com/zhayujie/chatgpt-on-wechat/commit/229b14b6fcabe7123d53cab1dea39f38dab26d6d), [8674421](https://github.com/zhayujie/chatgpt-on-wechat/commit/867442155e7f095b4f38b0856f8c1d8312b5fcf7))
- **model_type validation**: Fixed `AttributeError` caused by non-string `model_type` ([#2666](https://github.com/zhayujie/chatgpt-on-wechat/pull/2666))
+- **Scheduler memory loss**: Fixed memory loss caused by Scheduler dispatcher ([a77a874](https://github.com/zhayujie/CowAgent/commit/a77a8741b500a408c6f5c8868856fb4b018fe9db))
+- **Empty tool calls & long results**: Fixed handling of empty tool calls and excessively long tool results ([0542700](https://github.com/zhayujie/CowAgent/commit/0542700f9091ebb08c1a56103b0f0f45f24aa621))
+- **OpenAI Function Call**: Fixed function call compatibility with OpenAI models ([158c87a](https://github.com/zhayujie/CowAgent/commit/158c87ab8b05bae054cc1b4eacdbb64fc1062ba9))
+- **Claude tool name field**: Removed extraneous tool name field from Claude model responses ([eec10cb](https://github.com/zhayujie/CowAgent/commit/eec10cb5db6a3d5bc12ef606606532237d2c5f6e))
+- **MiniMax reasoning**: Optimized MiniMax model reasoning content handling, hidden thinking process output ([c72cda3](https://github.com/zhayujie/CowAgent/commit/c72cda33864bd1542012ee6e0a8bd8c6c88cb5ed), [72b1cac](https://github.com/zhayujie/CowAgent/commit/72b1cacea1ba0d1f3dedacbab2e088e98fd7e172))
+- **GLM thinking process**: Hidden GLM model thinking process display ([72b1cac](https://github.com/zhayujie/CowAgent/commit/72b1cacea1ba0d1f3dedacbab2e088e98fd7e172))
+- **Feishu connection & SSL**: Fixed Feishu channel SSL certificate errors and connection issues ([229b14b](https://github.com/zhayujie/CowAgent/commit/229b14b6fcabe7123d53cab1dea39f38dab26d6d), [8674421](https://github.com/zhayujie/CowAgent/commit/867442155e7f095b4f38b0856f8c1d8312b5fcf7))
+- **model_type validation**: Fixed `AttributeError` caused by non-string `model_type` ([#2666](https://github.com/zhayujie/CowAgent/pull/2666))

 ## Platform Compatibility

- **Windows compatibility**: Fixed path handling, file encoding, and `os.getuid()` unavailability on Windows across multiple tool modules ([051ffd7](https://github.com/zhayujie/chatgpt-on-wechat/commit/051ffd78a372f71a967fd3259e37fe19131f83cf), [5264f7c](https://github.com/zhayujie/chatgpt-on-wechat/commit/5264f7ce18360ee4db5dcb4ebe67307977d40014))
+- **Windows compatibility**: Fixed path handling, file encoding, and `os.getuid()` unavailability on Windows across multiple tool modules ([051ffd7](https://github.com/zhayujie/CowAgent/commit/051ffd78a372f71a967fd3259e37fe19131f83cf), [5264f7c](https://github.com/zhayujie/CowAgent/commit/5264f7ce18360ee4db5dcb4ebe67307977d40014))
--- a/docs/en/releases/v2.0.2.mdx
+++ b/docs/en/releases/v2.0.2.mdx
@@ -3,7 +3,7 @@ title: v2.0.2
 description: CowAgent 2.0.2 - Web Console upgrade, multi-channel concurrency, session persistence
 ---

-**Release Date**: 2026.02.27 | [Full Changelog](https://github.com/zhayujie/chatgpt-on-wechat/compare/2.0.1...master)
+**Release Date**: 2026.02.27 | [Full Changelog](https://github.com/zhayujie/CowAgent/compare/2.0.1...master)

 ## Highlights

@@ -53,7 +53,7 @@ View Agent runtime logs in real-time for monitoring and troubleshooting:

 <img width="850" src="https://cdn.link-ai.tech/doc/20260227173514.png" />

-Related commits: [f1a1413](https://github.com/zhayujie/chatgpt-on-wechat/commit/f1a1413), [c0702c8](https://github.com/zhayujie/chatgpt-on-wechat/commit/c0702c8), [394853c](https://github.com/zhayujie/chatgpt-on-wechat/commit/394853c), [1c71c4e](https://github.com/zhayujie/chatgpt-on-wechat/commit/1c71c4e), [5e3eccb](https://github.com/zhayujie/chatgpt-on-wechat/commit/5e3eccb), [e1dc037](https://github.com/zhayujie/chatgpt-on-wechat/commit/e1dc037), [5edbf4c](https://github.com/zhayujie/chatgpt-on-wechat/commit/5edbf4c), [7d258b5](https://github.com/zhayujie/chatgpt-on-wechat/commit/7d258b5)
+Related commits: [f1a1413](https://github.com/zhayujie/CowAgent/commit/f1a1413), [c0702c8](https://github.com/zhayujie/CowAgent/commit/c0702c8), [394853c](https://github.com/zhayujie/CowAgent/commit/394853c), [1c71c4e](https://github.com/zhayujie/CowAgent/commit/1c71c4e), [5e3eccb](https://github.com/zhayujie/CowAgent/commit/5e3eccb), [e1dc037](https://github.com/zhayujie/CowAgent/commit/e1dc037), [5edbf4c](https://github.com/zhayujie/CowAgent/commit/5edbf4c), [7d258b5](https://github.com/zhayujie/CowAgent/commit/7d258b5)

 ### 🔀 Multi-Channel Concurrency

@@ -67,24 +67,24 @@ Configuration: Set multiple channels in `config.json` via `channel_type` separat
 }
 ```

-Related commits: [4694594](https://github.com/zhayujie/chatgpt-on-wechat/commit/4694594), [7cce224](https://github.com/zhayujie/chatgpt-on-wechat/commit/7cce224), [7d258b5](https://github.com/zhayujie/chatgpt-on-wechat/commit/7d258b5), [c9adddb](https://github.com/zhayujie/chatgpt-on-wechat/commit/c9adddb)
+Related commits: [4694594](https://github.com/zhayujie/CowAgent/commit/4694594), [7cce224](https://github.com/zhayujie/CowAgent/commit/7cce224), [7d258b5](https://github.com/zhayujie/CowAgent/commit/7d258b5), [c9adddb](https://github.com/zhayujie/CowAgent/commit/c9adddb)

 ### 💾 Session Persistence

 Session history is now persisted to a local SQLite database. Conversation context is automatically restored after service restarts. Historical conversations in the Web Console are also restored.

-Related commits: [29bfbec](https://github.com/zhayujie/chatgpt-on-wechat/commit/29bfbec), [9917552](https://github.com/zhayujie/chatgpt-on-wechat/commit/9917552), [925d728](https://github.com/zhayujie/chatgpt-on-wechat/commit/925d728)
+Related commits: [29bfbec](https://github.com/zhayujie/CowAgent/commit/29bfbec), [9917552](https://github.com/zhayujie/CowAgent/commit/9917552), [925d728](https://github.com/zhayujie/CowAgent/commit/925d728)

 ## New Models

- **Gemini 3.1 Pro Preview**: Added `gemini-3.1-pro-preview` model support ([52d7cad](https://github.com/zhayujie/chatgpt-on-wechat/commit/52d7cad))
- **Claude 4.6 Sonnet**: Added `claude-4.6-sonnet` model support ([52d7cad](https://github.com/zhayujie/chatgpt-on-wechat/commit/52d7cad))
- **Qwen3.5 Plus**: Added `qwen3.5-plus` model support ([e59a289](https://github.com/zhayujie/chatgpt-on-wechat/commit/e59a289))
- **MiniMax M2.5**: Added `Minimax-M2.5` model support ([48db538](https://github.com/zhayujie/chatgpt-on-wechat/commit/48db538))
- **GLM-5**: Added `glm-5` model support ([48db538](https://github.com/zhayujie/chatgpt-on-wechat/commit/48db538))
- **Kimi K2.5**: Added `kimi-k2.5` model support ([48db538](https://github.com/zhayujie/chatgpt-on-wechat/commit/48db538))
- **Doubao 2.0 Code**: Added `doubao-2.0-code` coding-specialized model ([ab28ee5](https://github.com/zhayujie/chatgpt-on-wechat/commit/ab28ee5))
- **DashScope Models**: Added Alibaba Cloud DashScope model name support ([ce58f23](https://github.com/zhayujie/chatgpt-on-wechat/commit/ce58f23))
+- **Gemini 3.1 Pro Preview**: Added `gemini-3.1-pro-preview` model support ([52d7cad](https://github.com/zhayujie/CowAgent/commit/52d7cad))
+- **Claude 4.6 Sonnet**: Added `claude-4.6-sonnet` model support ([52d7cad](https://github.com/zhayujie/CowAgent/commit/52d7cad))
+- **Qwen3.5 Plus**: Added `qwen3.5-plus` model support ([e59a289](https://github.com/zhayujie/CowAgent/commit/e59a289))
+- **MiniMax M2.5**: Added `Minimax-M2.5` model support ([48db538](https://github.com/zhayujie/CowAgent/commit/48db538))
+- **GLM-5**: Added `glm-5` model support ([48db538](https://github.com/zhayujie/CowAgent/commit/48db538))
+- **Kimi K2.5**: Added `kimi-k2.5` model support ([48db538](https://github.com/zhayujie/CowAgent/commit/48db538))
+- **Doubao 2.0 Code**: Added `doubao-2.0-code` coding-specialized model ([ab28ee5](https://github.com/zhayujie/CowAgent/commit/ab28ee5))
+- **DashScope Models**: Added Alibaba Cloud DashScope model name support ([ce58f23](https://github.com/zhayujie/CowAgent/commit/ce58f23))

 ## Website & Documentation

@@ -93,6 +93,6 @@ Related commits: [29bfbec](https://github.com/zhayujie/chatgpt-on-wechat/commit/

 ## Bug Fixes

- **Gemini DingTalk image recognition**: Fixed Gemini unable to process image markers in DingTalk channel ([05a3304](https://github.com/zhayujie/chatgpt-on-wechat/commit/05a3304)) ([#2670](https://github.com/zhayujie/chatgpt-on-wechat/pull/2670)) Thanks [@SgtPepper114](https://github.com/SgtPepper114)
- **Startup script dependencies**: Fixed dependency installation issue in `run.sh` script ([b6fc9fa](https://github.com/zhayujie/chatgpt-on-wechat/commit/b6fc9fa))
- **Bare except cleanup**: Replaced `bare except` with `except Exception` for better exception handling ([adca89b](https://github.com/zhayujie/chatgpt-on-wechat/commit/adca89b)) ([#2674](https://github.com/zhayujie/chatgpt-on-wechat/pull/2674)) Thanks [@haosenwang1018](https://github.com/haosenwang1018)
+- **Gemini DingTalk image recognition**: Fixed Gemini unable to process image markers in DingTalk channel ([05a3304](https://github.com/zhayujie/CowAgent/commit/05a3304)) ([#2670](https://github.com/zhayujie/CowAgent/pull/2670)) Thanks [@SgtPepper114](https://github.com/SgtPepper114)
+- **Startup script dependencies**: Fixed dependency installation issue in `run.sh` script ([b6fc9fa](https://github.com/zhayujie/CowAgent/commit/b6fc9fa))
+- **Bare except cleanup**: Replaced `bare except` with `except Exception` for better exception handling ([adca89b](https://github.com/zhayujie/CowAgent/commit/adca89b)) ([#2674](https://github.com/zhayujie/CowAgent/pull/2674)) Thanks [@haosenwang1018](https://github.com/haosenwang1018)
--- a/docs/en/releases/v2.0.4.mdx
+++ b/docs/en/releases/v2.0.4.mdx
@@ -16,40 +16,40 @@ Added personal WeChat (`weixin`) channel — the most important update in this r

 Documentation: [WeChat Channel](https://docs.cowagent.ai/channels/weixin).

-Related commits: [ce89869](https://github.com/zhayujie/chatgpt-on-wechat/commit/ce89869), [a483ec0](https://github.com/zhayujie/chatgpt-on-wechat/commit/a483ec0), [c1421e0](https://github.com/zhayujie/chatgpt-on-wechat/commit/c1421e0)
+Related commits: [ce89869](https://github.com/zhayujie/CowAgent/commit/ce89869), [a483ec0](https://github.com/zhayujie/CowAgent/commit/a483ec0), [c1421e0](https://github.com/zhayujie/CowAgent/commit/c1421e0)

 ## 🤖 New Models

 - **MiniMax-M2.7**: Added MiniMax-M2.7 model support
 - **GLM-5-Turbo**: Added Zhipu glm-5-turbo model support

-Related commits: [9192f6f](https://github.com/zhayujie/chatgpt-on-wechat/commit/9192f6f)
+Related commits: [9192f6f](https://github.com/zhayujie/CowAgent/commit/9192f6f)

 ## 🔧 Script Refactoring

- **run.sh Refactoring**: Extracted shared logic and eliminated duplication, reducing from 600+ lines to 177 lines ([49d8707](https://github.com/zhayujie/chatgpt-on-wechat/commit/49d8707))
- **Executable Permission**: Fixed `run.sh` file permission issue ([652156e](https://github.com/zhayujie/chatgpt-on-wechat/commit/652156e))
+- **run.sh Refactoring**: Extracted shared logic and eliminated duplication, reducing from 600+ lines to 177 lines ([49d8707](https://github.com/zhayujie/CowAgent/commit/49d8707))
+- **Executable Permission**: Fixed `run.sh` file permission issue ([652156e](https://github.com/zhayujie/CowAgent/commit/652156e))

 ## ⚡ Improvements

- **Unified Request Headers**: Added identification headers to external requests across Agent services (Chat, Embedding, Vision, WebSearch, etc.) ([b4e711f](https://github.com/zhayujie/chatgpt-on-wechat/commit/b4e711f))
- **Auto-Repair Messages**: Enhanced message protocol fault tolerance with automatic repair of malformed message sequences ([b8b57e3](https://github.com/zhayujie/chatgpt-on-wechat/commit/b8b57e3))
+- **Unified Request Headers**: Added identification headers to external requests across Agent services (Chat, Embedding, Vision, WebSearch, etc.) ([b4e711f](https://github.com/zhayujie/CowAgent/commit/b4e711f))
+- **Auto-Repair Messages**: Enhanced message protocol fault tolerance with automatic repair of malformed message sequences ([b8b57e3](https://github.com/zhayujie/CowAgent/commit/b8b57e3))

 ## 🌍 Japanese Documentation

 Added complete Japanese documentation covering getting started guide, channel integration, model configuration and other major sections. Thanks [@Ikko Ashimine](https://github.com/ikoamu)

-Related commits: [5487c0b](https://github.com/zhayujie/chatgpt-on-wechat/commit/5487c0b)
+Related commits: [5487c0b](https://github.com/zhayujie/CowAgent/commit/5487c0b)

 ## 🐛 Bug Fixes

- **WeCom Bot Compatibility**: Fixed compatibility with older `websocket-client` versions, added unified WebSocket compatibility layer ([bc7f627](https://github.com/zhayujie/chatgpt-on-wechat/commit/bc7f627))
- **run.sh PID**: Fixed process PID retrieval error in `run.sh` ([9febb07](https://github.com/zhayujie/chatgpt-on-wechat/commit/9febb07))
- **Feishu Encoding**: Fixed message and log encoding issue in Feishu channel ([7d0e156](https://github.com/zhayujie/chatgpt-on-wechat/commit/7d0e156))
- **Feishu Config**: Removed redundant `feishu_bot_name` dependency in `run.sh` ([1b5be1b](https://github.com/zhayujie/chatgpt-on-wechat/commit/1b5be1b))
+- **WeCom Bot Compatibility**: Fixed compatibility with older `websocket-client` versions, added unified WebSocket compatibility layer ([bc7f627](https://github.com/zhayujie/CowAgent/commit/bc7f627))
+- **run.sh PID**: Fixed process PID retrieval error in `run.sh` ([9febb07](https://github.com/zhayujie/CowAgent/commit/9febb07))
+- **Feishu Encoding**: Fixed message and log encoding issue in Feishu channel ([7d0e156](https://github.com/zhayujie/CowAgent/commit/7d0e156))
+- **Feishu Config**: Removed redundant `feishu_bot_name` dependency in `run.sh` ([1b5be1b](https://github.com/zhayujie/CowAgent/commit/1b5be1b))

 ## 📦 Upgrade

 Run `./run.sh update` for a one-click upgrade, or manually pull the latest code and restart. See [Upgrade Guide](https://docs.cowagent.ai/guide/upgrade) for details.

-**Release Date**: 2026.03.22 | [Full Changelog](https://github.com/zhayujie/chatgpt-on-wechat/compare/2.0.3...master)
+**Release Date**: 2026.03.22 | [Full Changelog](https://github.com/zhayujie/CowAgent/compare/2.0.3...master)
--- a/docs/en/releases/v2.0.5.mdx
+++ b/docs/en/releases/v2.0.5.mdx
@@ -0,0 +1,77 @@
+---
+title: v2.0.5
+description: CowAgent 2.0.5 - Cow CLI, Skill Hub open source, Browser tool, WeCom Bot QR scan, and more
+---
+
+## 🖥️ Cow CLI
+
+New CLI command system for managing CowAgent from terminal and chat:
+
+- **Terminal commands**: Run `cow <command>` for `start`, `stop`, `restart`, `update`, `status`, `logs`, etc.
+- **Chat commands**: Type `/<command>` in conversation for `/help`, `/status`, `/config`, `/skill`, `/context`, `/logs`, `/version`, etc.
+- **Web console**: Type `/` in the input box to open a slash command menu, with arrow-key input history
+- **Windows support**: New PowerShell script `scripts/run.ps1` with `cow` command support
+
+Docs: [Command Overview](https://docs.cowagent.ai/en/cli)
+
+<img src="https://cdn.link-ai.tech/doc/20260401114549.png" width="750" />
+
+## 🧩 Cow Skill Hub Open Source
+
+[Cow Skill Hub](https://skills.cowagent.ai) is now open source and live — browse, search, install, and publish AI Agent skills:
+
+- **One-command install**: `/skill install <name>` in chat or `cow skill install <name>` in terminal
+- **Multi-source**: Install from Skill Hub, GitHub, ClawHub, LinkAI, and more
+- **Search**: `/skill search` and `/skill list --remote` to browse the hub
+- **Publish**: Submit your own skills at [skills.cowagent.ai/submit](https://skills.cowagent.ai/submit)
+- **Mirror**: Mirror acceleration for faster downloads in China
+
+Open source repo: [cow-skill-hub](https://github.com/zhayujie/cow-skill-hub)
+
+Docs: [Skill Hub](https://docs.cowagent.ai/en/skills/hub), [Install Skills](https://docs.cowagent.ai/en/skills/install)
+
+<img src="https://cdn.link-ai.tech/doc/20260401110103.png" width="750" />
+
+## 🌐 Browser Tool
+
+New Browser tool — Agent can control a Chromium browser to visit and interact with web pages:
+
+- **Navigation & interaction**: `navigate`, `click`, `fill`, `select`, `scroll`, `press`, etc.
+- **Page snapshot**: Compact DOM snapshot for efficient page understanding, auto-snapshot after navigation
+- **Screenshot**: Save page screenshots to workspace
+- **JavaScript execution**: Run custom scripts on pages
+- **CLI install**: `cow install-browser` for one-command setup
+- **Docker support**: Browser install built into Docker image
+
+Docs: [Browser Tool](https://docs.cowagent.ai/en/tools/browser)
+
+<img src="https://cdn.link-ai.tech/doc/20260401115728.png" width="750" />
+
+## 🤖 WeCom Bot QR Code Setup
+
+WeCom Bot channel now supports QR code scan for one-click bot creation:
+
+- **QR scan in Web console**: Select "Scan QR" mode, scan with WeCom to auto-create and connect a bot — no manual configuration needed
+- **Manual mode**: Still supports manual Bot ID and Secret input
+- **Stream push optimization**: Throttled push to avoid WebSocket congestion
+
+Docs: [WeCom Bot](https://docs.cowagent.ai/en/channels/wecom-bot)
+
+PR: [#2735](https://github.com/zhayujie/CowAgent/pull/2735). Thanks [@WecomTeam](https://github.com/WecomTeam)
+
+## 🐛 Other Improvements & Fixes
+
+- **DeepSeek module**: Independent DeepSeek Bot with dedicated `deepseek_api_key` config ([#2719](https://github.com/zhayujie/CowAgent/pull/2719)). Thanks [@6vision](https://github.com/6vision)
+- **Web console**: Slash command menu, input history, new model options, mobile optimization ([#2731](https://github.com/zhayujie/CowAgent/pull/2731)). Thanks [@zkjqd](https://github.com/zkjqd)
+- **Context loss**: Fix context loss after trimming ([393f0c0](https://github.com/zhayujie/CowAgent/commit/393f0c0))
+- **System prompt**: Fix system prompt not rebuilding on every turn ([13f5fde](https://github.com/zhayujie/CowAgent/commit/13f5fde))
+- **Gemini**: Fix missing model attribute in GoogleGeminiBot ([#2716](https://github.com/zhayujie/CowAgent/pull/2716)). Thanks [@cowagent](https://github.com/cowagent)
+- **WeChat channel**: Fix file send failures and filename loss ([6d9b7ba](https://github.com/zhayujie/CowAgent/commit/6d9b7ba), [45faa9c](https://github.com/zhayujie/CowAgent/commit/45faa9c))
+- **Docker**: Fix volume permissions, reduce image size ([3eb8348](https://github.com/zhayujie/CowAgent/commit/3eb8348), [4470d4c](https://github.com/zhayujie/CowAgent/commit/4470d4c))
+- **Security**: Fix Memory Content path traversal risk. Thanks [@August829](https://github.com/August829)
+
+## 📦 Upgrade
+
+Run `cow update` or `./run.sh update` to upgrade, or pull the latest code and restart. See [Upgrade Guide](https://docs.cowagent.ai/en/guide/upgrade).
+
+**Release Date**: 2026.04.01 | [Full Changelog](https://github.com/zhayujie/CowAgent/compare/2.0.4...master)
--- a/docs/en/releases/v2.0.6.mdx
+++ b/docs/en/releases/v2.0.6.mdx
@@ -0,0 +1,83 @@
+---
+title: v2.0.6
+description: CowAgent 2.0.6 - Knowledge Base, Deep Dream Memory Distillation, Smart Context Compression, Web Console Multi-Session and More
+---
+
+## Project Renamed to CowAgent
+
+The repository has been officially renamed from `chatgpt-on-wechat` to **CowAgent**, evolving into a full-featured AI Agent assistant.
+
+- New URL: [github.com/zhayujie/CowAgent](https://github.com/zhayujie/CowAgent) — GitHub auto-redirects the old URL
+- CLI commands, config files, and documentation links remain compatible — no extra steps needed
+
+## 📚 Knowledge Base
+
+New personal knowledge base system — Agent can autonomously build and maintain structured knowledge, retrieving it on demand during conversations:
+
+- **Index-driven self-organizing structure**: Knowledge is stored in `knowledge/` directory, auto-organized by category, with each knowledge page as an independent Markdown file
+- **Auto-write**: Send files, links, or other knowledge to the Agent, or it will automatically create/update knowledge pages when valuable information is identified in conversation
+- **Hybrid retrieval**: Supports keyword full-text search and vector semantic retrieval, loading relevant knowledge on demand during conversations
+- **Visualization**: File tree browsing and knowledge graph visualization, with in-document links for direct navigation
+- **Command management**: `/knowledge` for stats, `/knowledge list` for directory structure, `/knowledge on|off` to toggle
+
+<img src="https://cdn.link-ai.tech/doc/20260413105435.png" width="750" />
+
+
+Docs: [Knowledge Base](https://docs.cowagent.ai/en/knowledge)
+
+## 🌙 Deep Dream Memory Distillation
+
+A new memory consolidation mechanism that automatically distills scattered conversation memories into refined long-term memory daily:
+
+- **Three-tier memory flow**: Conversation context (short-term) → Daily memory (mid-term) → MEMORY.md (long-term), forming a complete memory lifecycle
+- **Auto-distillation**: Runs daily at 23:55, reads the day's daily memory and MEMORY.md, performs deduplication, merging, and pruning via LLM, outputting a refined MEMORY.md
+- **Dream diary**: Each distillation generates a narrative-style dream diary recording discoveries and insights, stored in `memory/dreams/`
+- **Manual trigger**: `/memory dream [N]` to manually trigger with configurable lookback days (default 3, max 30), with chat notification on completion
+- **Web console**: Memory management page now includes a "Dream Diary" tab for browsing all dream diaries
+
+Docs: [Deep Dream](https://docs.cowagent.ai/en/memory/deep-dream)
+
+<img src="https://cdn.link-ai.tech/doc/20260414120158.png" width="750" />
+
+## 🧠 Smart Context Compression
+
+When context exceeds limits, trimmed portions are summarized by LLM and asynchronously injected to maintain conversation continuity:
+
+- **Async LLM summary**: Trimmed messages are summarized into key information by LLM, written to daily memory files and injected into retained context
+- **Multi-model compatible**: Uses the primary model for summarization, compatible with Claude, OpenAI, MiniMax and other model message format requirements
+
+Docs: [Short-term Memory](https://docs.cowagent.ai/en/memory/context)
+
+## 💬 Web Console Upgrades
+
+Multiple enhancements to the Web console:
+
+- **Multi-session management**: Create and switch between independent sessions, sidebar session list with auto-generated and manually editable titles
+- **Password protection**: Set a login password via `web_console_password` config option
+- **Deep thinking**: Display model thinking process in Web console, controlled by `enable_thinking` config option
+- **Scheduled push**: Scheduled task results can be pushed to Web console
+- **Message copy**: One-click copy of raw Markdown content from AI reply bubbles
+- **Language toggle**: Top language switch button now shows current language for more intuitive interaction
+
+## 🤖 Model Updates
+
+- **Vision optimization**: Image recognition tool prefers the primary model with automatic multi-provider fallback. Docs: [Vision Tool](https://docs.cowagent.ai/en/tools/vision)
+- **MiniMax new model**: Added MiniMax-M2.7-highspeed model and MiniMax TTS voice synthesis support. Thanks @octo-patch
+- **Qwen**: Added qwen3.6-plus model support
+
+## 🐛 Other Improvements & Fixes
+
+- **Memory prompts**: `MEMORY.md` injected into system prompt by default, with refined memory retrieval and write trigger conditions for enhanced proactive writing
+- **System prompt**: Optimized system prompt style and tone guidance
+- **Browser tool**: Enhanced implicit interactive element detection
+- **File send**: Fixed common file types (tar.gz, zip, etc.) not being sent correctly. Thanks @6vision
+- **macOS compatibility**: Fixed network pre-check timeout compatibility issue. Thanks @Moliang Zhou
+- **Windows compatibility**: Fixed PowerShell compatibility, process updates, terminal encoding and other issues on Windows
+- **Python 3.13+**: Fixed missing `legacy-cgi` dependency for Python 3.13+
+- **WeChat channel**: Updated personal WeChat channel version
+
+## 📦 Upgrade
+
+Run `cow update` or `./run.sh update` to upgrade, or pull the latest code and restart. See [Upgrade Guide](https://docs.cowagent.ai/en/guide/upgrade).
+
+**Release Date**: 2026.04.14 | [Full Changelog](https://github.com/zhayujie/CowAgent/compare/2.0.5...master)
--- a/docs/en/skills/create.mdx
+++ b/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/CowAgent/blob/master/skills/skill-creator/SKILL.md) for details.
+</Tip>
--- a/docs/en/skills/image-vision.mdx
+++ b/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>
--- a/docs/en/skills/index.mdx
+++ b/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/cli/skill) for details. You can also [create skills](/en/skills/create) through conversation.

 ## Skill Loading Priority

--- a/docs/en/skills/install.mdx
+++ b/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/cli/skill) for full documentation.
+</Tip>
--- a/docs/en/skills/linkai-agent.mdx
+++ b/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>
--- a/docs/en/skills/skill-creator.mdx
+++ b/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>
--- a/docs/en/skills/web-fetch.mdx
+++ b/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>
--- a/docs/en/tools/memory.mdx
+++ b/docs/en/tools/memory.mdx
@@ -1,9 +1,11 @@
 ---
-title: memory - Memory
-description: Search and read long-term memory
+title: memory - Memory & Knowledge
+description: Search and read long-term memory and knowledge base files
 ---

-The memory tool contains two sub-tools: `memory_search` (search memory) and `memory_get` (read memory files).
+The memory tool contains two sub-tools: `memory_search` (search memory) and `memory_get` (read memory or knowledge files).
+
+When the [knowledge base](/en/knowledge) feature is enabled, both tools also support accessing files under the `knowledge/` directory.

 ## Dependencies

@@ -11,7 +13,7 @@ No extra dependencies, available by default. Managed by the Agent Core memory sy

 ## memory_search

-Search historical memory with hybrid keyword and vector retrieval.
+Search historical memory and knowledge base content with hybrid keyword and vector retrieval.

 | Parameter | Type | Required | Description |
 | --- | --- | --- | --- |
@@ -19,11 +21,11 @@ Search historical memory with hybrid keyword and vector retrieval.

 ## memory_get

-Read the content of a specific memory file.
+Read the content of a specific memory or knowledge file.

 | Parameter | Type | Required | Description |
 | --- | --- | --- | --- |
-| `path` | string | Yes | Relative path to memory file (e.g. `MEMORY.md`, `memory/2026-01-01.md`) |
+| `path` | string | Yes | Relative path to the file (e.g. `MEMORY.md`, `memory/2026-01-01.md`, `knowledge/concepts/rag.md`) |
 | `start_line` | integer | No | Start line number |
 | `end_line` | integer | No | End line number |

@@ -34,3 +36,8 @@ The Agent automatically invokes memory tools in these scenarios:
 - When the user shares important information → stores to memory
 - When historical context is needed → searches relevant memory
 - When conversation reaches a certain length → extracts summary for storage
+- When discussing domain knowledge → retrieves relevant pages from the knowledge base
+
+<Note>
+  When `knowledge` is set to `false` in config, the tool descriptions and search scope automatically adjust to include only memory files.
+</Note>
--- a/docs/en/tools/vision.mdx
+++ b/docs/en/tools/vision.mdx
@@ -0,0 +1,72 @@
+---
+title: vision - Image Analysis
+description: Analyze image content (recognition, description, OCR, etc.)
+---
+
+Analyze local images or image URLs using Vision API. Supports content description, text extraction (OCR), object recognition, and more.
+
+## Model Selection
+
+The vision tool uses a multi-level auto-selection strategy with automatic fallback — no manual configuration required:
+
+1. **Main model** — uses the currently configured main model for image recognition (zero extra cost)
+2. **Other configured models** — auto-discovers other models with configured API keys as alternatives
+3. **OpenAI** — uses `open_ai_api_key` to call gpt-4.1-mini
+4. **LinkAI** — uses `linkai_api_key` to call LinkAI vision service
+
+When `use_linkai=true`, LinkAI is promoted to the highest priority.
+
+If the current provider fails, the tool automatically tries the next one until it succeeds or all fail.
+
+### Supported Models
+
+| Vendor | Vision Model | Notes |
+| --- | --- | --- |
+| OpenAI / Compatible | Main model | All OpenAI-compatible multimodal models |
+| Qwen (DashScope) | Main model | Via MultiModalConversation API |
+| Claude | Main model | Anthropic native image format |
+| Gemini | Main model | inlineData format |
+| Doubao | Main model | doubao-seed-2-0 series natively supported |
+| Kimi (Moonshot) | Main model | kimi-k2.5 natively supported |
+| ZhipuAI | glm-5v-turbo | Always uses dedicated vision model |
+| MiniMax | MiniMax-Text-01 | Always uses dedicated vision model |
+
+<Note>
+  ZhipuAI and MiniMax text models do not support image understanding, so their dedicated vision models are always used automatically.
+</Note>
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `image` | string | Yes | Local file path or HTTP(S) image URL |
+| `question` | string | Yes | Question to ask about the image |
+
+Supported image formats: jpg, jpeg, png, gif, webp
+
+## Custom Configuration
+
+To specify a particular model for the vision tool, add to `config.json`:
+
+```json
+{
+    "tool": {
+        "vision": {
+            "model": "gpt-4o"
+        }
+    }
+}
+```
+
+In most cases no configuration is needed. The tool works automatically as long as the main model supports multimodal input or any vision-capable API key is configured.
+
+## Use Cases
+
+- Describe image content
+- Extract text from images (OCR)
+- Identify objects, colors, scenes
+- Analyze screenshots and scanned documents
+
+<Note>
+  Images larger than 1MB are automatically compressed (max edge 1536px). All images (including remote URLs) are converted to base64 for transmission to ensure compatibility with all model backends.
+</Note>
--- a/docs/guide/manual-install.mdx
+++ b/docs/guide/manual-install.mdx
@@ -8,12 +8,12 @@ description: 手动部署 CowAgent（源码 / Docker）
 ### 1. 克隆项目代码

 ```bash
-git clone https://github.com/zhayujie/chatgpt-on-wechat
-cd chatgpt-on-wechat/
+git clone https://github.com/zhayujie/CowAgent
+cd CowAgent/
 ```

 <Tip>
-  若遇到网络问题可使用国内仓库地址：https://gitee.com/zhayujie/chatgpt-on-wechat
+  若遇到网络问题可使用国内仓库地址：https://gitee.com/zhayujie/CowAgent
 </Tip>

 ### 2. 安装依赖
@@ -32,7 +32,39 @@ pip3 install -r requirements-optional.txt

 > 国内网络可使用镜像源加速：`pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple`

-### 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>
+
+### 3.1 安装浏览器工具（可选）
+
+如需使用浏览器工具（控制浏览器访问网页、填写表单等），运行：
+
+```bash
+cow install-browser
+```
+
+该命令会自动安装 Playwright 和 Chromium 浏览器。详细说明参考 [浏览器工具文档](/tools/browser)。
+
+<Note>
+  浏览器工具依赖较重（~300MB），如不需要可跳过，不影响其他功能正常使用。
+</Note>
+
+### 4. 配置

 复制配置文件模板并编辑：

@@ -42,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
@@ -52,7 +90,7 @@ python3 app.py

 运行后默认启动 Web 控制台，访问 `http://localhost:9899` 开始对话和管理Agent。

-**服务器后台运行：**
+**服务器后台运行（不使用 CLI 时）：**

 ```bash
 nohup python3 app.py & tail -f nohup.out
@@ -96,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/CowAgent/blob/master/config.py) 文件中查看。Docker 部署时，配置项名称需转为大写环境变量格式。
 </Tip>
--- a/docs/guide/quick-start.mdx
+++ b/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 依赖
+3. 克隆项目代码到 `~/CowAgent`
+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` | 安装浏览器工具依赖 |
+
+更多命令和用法参考 [命令文档](/cli/index)。
+
+<Note>
+  如果 `cow` 命令不可用，也可以使用 `./run.sh <命令>`（Linux/macOS）或 `.\scripts\run.ps1 <命令>`（Windows）作为替代，功能等效。
+</Note>
--- a/docs/guide/upgrade.mdx
+++ b/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
 ```
--- a/docs/intro/architecture.mdx
+++ b/docs/intro/architecture.mdx
@@ -11,25 +11,27 @@ CowAgent 的整体架构由以下核心模块组成：

 <img src="https://cdn.link-ai.tech/doc/68ef7b212c6f791e0e74314b912149f9-sz_5847990.png" alt="CowAgent Architecture" />

-### 核心模块说明
-
 | 模块 | 说明 |
 | --- | --- |
-| **Channels** | 消息通道层，负责接收和发送消息，支持 Web、飞书、钉钉、企微、公众号等 |
-| **Agent Core** | 智能体核心引擎，包括任务规划、记忆系统和技能引擎 |
-| **Tools** | 工具层，Agent 通过工具访问操作系统资源，内置 10+ 种工具 |
-| **Models** | 模型层，支持国内外主流大语言模型的统一接入 |
+| **Plan** | 理解用户意图，将复杂任务分解为多步骤计划，循环调用工具直到完成目标 |
+| **Memory** | 自动将重要信息持久化为核心记忆和日级记忆，支持关键词和向量混合检索，跨会话保持上下文连续性 |
+| **Knowledge** | 以主题维度组织结构化知识，Agent 自主整理有价值信息为 Markdown 页面，维护索引和交叉引用，构建持续增长的知识网络 |
+| **Tools** | Agent 访问操作系统资源的核心能力，内置文件读写、终端执行、浏览器操作、定时调度、记忆检索、联网搜索等 10+ 种工具 |
+| **Skills** | 加载和管理 Skills，支持从 Skill Hub、GitHub 等一键安装，或通过对话创建自定义技能 |
+| **Models** | 模型层，统一接入 OpenAI、Claude、Gemini、DeepSeek、MiniMax、GLM、Qwen 等国内外主流大语言模型 |
+| **Channels** | 消息通道层，负责接收和发送消息，支持 Web 控制台、微信、飞书、钉钉、企微、公众号等，统一消息协议 |
+| **CLI** | 命令行系统，提供终端命令（`cow`）和对话命令（`/`），支持进程管理、技能安装、配置修改、知识库管理等操作 |

 ## Agent 模式

 启用 Agent 模式后，CowAgent 会以自主智能体的方式运行，核心工作流如下：

-1. **接收消息** - 通过通道接收用户输入
-2. **理解意图** - 分析任务需求和上下文
-3. **规划任务** - 将复杂任务分解为多个步骤
-4. **调用工具** - 选择合适的工具执行每个步骤
-5. **记忆更新** - 将重要信息存入长期记忆
-6. **返回结果** - 将执行结果发送回用户
+1. **接收消息** — 通过通道接收用户输入
+2. **理解意图** — 分析任务需求和上下文
+3. **规划任务** — 将复杂任务分解为多个步骤
+4. **调用工具** — 选择合适的工具执行每个步骤
+5. **记忆与知识更新** — 将重要信息存入长期记忆，将结构化知识整理至知识库
+6. **返回结果** — 将执行结果发送回用户

 ## 工作空间

@@ -37,11 +39,14 @@ Agent 的工作空间默认位于 `~/cow` 目录，用于存储系统提示词

 ```
 ~/cow/
-├── system.md          # Agent system prompt
-├── user.md            # User profile
+├── SYSTEM.md          # Agent system prompt
+├── USER.md            # User profile
+├── MEMORY.md          # Core memory
 ├── memory/            # Long-term memory storage
-│   ├── core.md        # Core memory
-│   └── daily/         # Daily memory
+│   └── YYYY-MM-DD.md  # Daily memory
+├── knowledge/         # Personal knowledge base
+│   ├── index.md       # Knowledge index
+│   └── <category>/    # Topic-based pages
 └── skills/            # Custom skills
    ├── skill-1/
    └── skill-2/
@@ -64,7 +69,8 @@ Agent 的工作空间默认位于 `~/cow` 目录，用于存储系统提示词
  "agent_workspace": "~/cow",
  "agent_max_context_tokens": 40000,
  "agent_max_context_turns": 30,
-  "agent_max_steps": 15
+  "agent_max_steps": 15,
+  "enable_thinking": true
 }
 ```

@@ -72,6 +78,8 @@ Agent 的工作空间默认位于 `~/cow` 目录，用于存储系统提示词
 | --- | --- | --- |
 | `agent` | 是否启用 Agent 模式 | `true` |
 | `agent_workspace` | 工作空间路径 | `~/cow` |
-| `agent_max_context_tokens` | 最大上下文 token 数 | `40000` |
-| `agent_max_context_turns` | 最大上下文记忆轮次 | `30` |
-| `agent_max_steps` | 单次任务最大决策步数 | `15` |
+| `agent_max_context_tokens` | 最大上下文 token 数 | `50000` |
+| `agent_max_context_turns` | 最大上下文记忆轮次 | `20` |
+| `agent_max_steps` | 单次任务最大决策步数 | `20` |
+| `enable_thinking` | 是否启用深度思考，开启后 Web 端展示推理过程，关闭可加速响应 | `true` |
+| `knowledge` | 是否启用个人知识库 | `true` |
--- a/docs/intro/features.mdx
+++ b/docs/intro/features.mdx
@@ -1,27 +1,46 @@
 ---
 title: 功能介绍
-description: CowAgent 长期记忆、任务规划、技能系统详细说明
+description: CowAgent 长期记忆、个人知识库、任务规划、技能系统、CLI 命令、浏览器工具详细说明
 ---

 ## 1. 长期记忆

-> 记忆系统让 Agent 能够长期记住重要信息。Agent 会在用户分享偏好、决策、事实等重要信息时主动存储，也会在对话达到一定长度时自动提取摘要。记忆分为核心记忆、天级记忆，支持语义搜索和向量检索的混合检索模式。
+> 记忆系统让 Agent 能够长期记住重要信息，采用三层记忆流转架构：对话上下文（短期）→ 天级记忆（中期）→ MEMORY.md（长期），形成完整的记忆生命周期。

 第一次启动 Agent 时，Agent 会主动询问关键信息，并记录至工作空间（默认 `~/cow`）中的智能体设定、用户身份、记忆文件中。

-在后续的长期对话中，Agent 会在需要时智能记录或检索记忆，并对自身设定、用户偏好、记忆文件等进行不断更新，总结和记录经验和教训，真正实现自主思考和不断成长。
+在后续的长期对话中，Agent 会在需要时智能记录或检索记忆，并对自身设定、用户偏好、记忆文件等进行不断更新。每日自动执行 **梦境蒸馏（Deep Dream）**，将分散的天级记忆整合为精炼的长期记忆，同时生成叙事风格的梦境日记。

 <Frame>
  <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
 </Frame>

-## 2. 任务规划和工具调用
+详细说明请参考 [长期记忆](/memory) 和 [梦境蒸馏](/memory/deep-dream)。
+
+## 2. 个人知识库
+
+> 知识库系统让 Agent 能够持续积累和组织结构化知识。与按时间线记录的记忆不同，知识库以主题为维度，将文章、对话洞察、学习材料等整理为互相关联的 Markdown 页面，形成持续增长的知识网络。
+
+Agent 会在对话中自动将有价值的信息整理为知识页面，维护交叉引用和索引，通过 Web 控制台可浏览文档和查看知识图谱。知识库存储在工作空间的 `~/cow/knowledge/` 目录下。
+
+- **自动整理**：Agent 在对话中自主提取和整理结构化知识，维护索引和交叉引用
+- **知识图谱**：基于页面间的交叉引用自动构建知识图谱，Web 控制台提供可视化关系图浏览
+- **对话联动**：Agent 回复中引用的知识文档链接可在 Web 控制台中直接点击跳转查看
+- **CLI 管理**：通过 `/knowledge` 命令查看统计、浏览目录，通过 `/knowledge on|off` 开关功能
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260413105435.png" width="800" />
+</Frame>
+
+详细说明请参考 [个人知识库](/knowledge)。
+
+## 3. 任务规划和工具调用

 工具是 Agent 访问操作系统资源的核心，Agent 会根据任务需求智能选择和调用工具，完成文件读写、命令执行、定时任务等各类操作。内置工具的实现在项目的 `agent/tools/` 目录下。

-**主要工具：** 文件读写编辑、Bash 终端、文件发送、定时调度、记忆搜索、联网搜索、环境配置等。
+**主要工具：** 文件读写编辑、Bash 终端、浏览器操作、文件发送、定时调度、记忆搜索、联网搜索、环境配置等。

-### 2.1 终端和文件访问
+### 3.1 终端和文件访问

 针对操作系统的终端和文件的访问能力，是最基础和核心的工具，其他很多工具或技能都是基于此进行扩展。用户可通过手机端与 Agent 交互，操作个人电脑或服务器上的资源：

@@ -29,15 +48,15 @@ description: CowAgent 长期记忆、任务规划、技能系统详细说明
  <img src="https://cdn.link-ai.tech/doc/20260202181130.png" width="800" />
 </Frame>

-### 2.2 编程能力
+### 3.2 编程能力

 基于编程能力和系统访问能力，Agent 可以实现从信息搜索、图片等素材生成、编码、测试、部署、Nginx 配置修改、发布的 **Vibecoding 全流程**，通过手机端简单的一句命令完成应用的快速 demo：

 <Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260203121008.png" width="800" />
+  <img src="https://cdn.link-ai.tech/doc/20260318211018.png" width="800" />
 </Frame>

-### 2.3 定时任务
+### 3.3 定时任务

 基于 `scheduler` 工具实现动态定时任务，支持**一次性任务、固定时间间隔、Cron 表达式**三种形式，任务触发可选择**固定消息发送**或 **Agent 动态任务**执行两种模式：

@@ -45,7 +64,15 @@ description: CowAgent 长期记忆、任务规划、技能系统详细说明
  <img src="https://cdn.link-ai.tech/doc/20260202195402.png" width="800" />
 </Frame>

-### 2.4 环境变量管理
+### 3.4 浏览器操作
+
+内置 `browser` 工具，Agent 可控制浏览器访问网页、填写表单、点击元素、截图，支持动态 JS 渲染页面。运行 `cow install-browser` 一键安装，自动适配服务器（无头模式）和桌面环境：
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260401115728.png" width="750" />
+</Frame>
+
+### 3.5 环境变量管理

 技能所需的秘钥存储在环境变量文件中，由 `env_config` 工具进行管理，你可以通过对话的方式更新秘钥，工具内置安全保护和脱敏策略：

@@ -53,14 +80,17 @@ description: CowAgent 长期记忆、任务规划、技能系统详细说明
  <img src="https://cdn.link-ai.tech/doc/20260202234939.png" width="800" />
 </Frame>

-## 3. 技能系统
+## 4. 技能系统

 技能系统为 Agent 提供无限的扩展性，每个 Skill 由说明文件、运行脚本（可选）、资源（可选）组成，描述如何完成特定类型的任务。通过 Skill 可以让 Agent 遵循说明完成复杂流程、调用各类工具或对接第三方系统。

+- **[Skill Hub](https://skills.cowagent.ai/)：** 开放的技能广场，汇集官方推荐、社区贡献和第三方技能，支持一键安装。
 - **内置技能：** 在项目的 `skills/` 目录下，包含技能创造器、图像识别、LinkAI 智能体、网页抓取等。内置 Skill 根据依赖条件（API Key、系统命令等）自动判断是否启用。
 - **自定义技能：** 由用户通过对话创建，存放在工作空间中（`~/cow/skills/`），可实现任何复杂的业务流程和第三方系统对接。

-### 3.1 创建技能
+安装技能：`/skill install <名称>` 或 `cow skill install <名称>`，支持从 Skill Hub、GitHub、ClawHub、URL 等来源安装。
+
+### 4.1 创建技能

 通过 `skill-creator` 技能可以通过对话的方式快速创建技能。你可以让 Agent 将某个工作流程固化为技能，或者把任意接口文档和示例发送给 Agent，让他直接完成对接：

@@ -68,7 +98,7 @@ description: CowAgent 长期记忆、任务规划、技能系统详细说明
  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
 </Frame>

-### 3.2 搜索和图像识别
+### 4.2 搜索和图像识别

 - **联网搜索：** 内置 `web_search` 工具，支持多种搜索引擎，配置 `BOCHA_API_KEY` 或 `LINKAI_API_KEY` 后启用。
 - **图像识别：** 内置 `openai-image-vision` 技能，可使用 `gpt-4.1-mini`、`gpt-4.1` 等模型，依赖 `OPENAI_API_KEY`。
@@ -77,29 +107,36 @@ description: CowAgent 长期记忆、任务规划、技能系统详细说明
  <img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
 </Frame>

-### 3.3 三方知识库和插件
+### 4.3 技能广场

-`linkai-agent` 技能可以将 [LinkAI](https://link-ai.tech/) 上的所有智能体作为 Skill 交给 Agent 使用，实现多智能体决策效果。
+访问 [skills.cowagent.ai](https://skills.cowagent.ai/) 浏览所有可用技能，或在对话中执行：

-配置方式：通过 `env_config` 配置 `LINKAI_API_KEY`，并在 `skills/linkai-agent/config.json` 中添加智能体说明：
-
-```json
-{
-  "apps": [
-    {
-      "app_code": "G7z6vKwp",
-      "app_name": "LinkAI客服助手",
-      "app_description": "当用户需要了解LinkAI平台相关问题时才选择该助手"
-    },
-    {
-      "app_code": "SFY5x7JR",
-      "app_name": "内容创作助手",
-      "app_description": "当用户需要创作图片或视频时才使用该助手"
-    }
-  ]
-}
+```text
+/skill list --remote          # 浏览技能广场
+/skill search <关键词>         # 搜索技能
+/skill install <名称>          # 一键安装
 ```

-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
-</Frame>
+同时还支持安装Github、ClawHub、LinkAI等第三方平台上的所有技能，详情查看 [技能安装](/skills/install)
+
+<img src="https://cdn.link-ai.tech/doc/20260401110103.png" width="750" />
+
+
+## 5. CLI 命令系统
+
+CowAgent 提供两种命令交互方式，覆盖服务管理、技能安装、配置调整等日常运维操作：
+
+- **终端 CLI：** 在系统终端执行 `cow <命令>`，支持 `start`、`stop`、`restart`、`update`、`status`、`logs`、`skill` 等
+- **对话命令：** 在对话中输入 `/<命令>`，Web 控制台输入 `/` 可弹出指令菜单快速选择
+
+```bash
+cow start              # 启动服务
+cow stop               # 停止服务
+cow update             # 更新并重启
+cow skill install pptx # 安装技能
+cow install-browser    # 安装浏览器工具
+```
+
+详细命令参考 [命令总览](https://docs.cowagent.ai/cli)。
+
+<img src="https://cdn.link-ai.tech/doc/20260401114549.png" width="750" />
--- a/docs/intro/index.mdx
+++ b/docs/intro/index.mdx
@@ -5,12 +5,12 @@ description: CowAgent - 基于大模型的超级AI助理

 <img src="https://cdn.link-ai.tech/doc/78c5dd674e2c828642ecc0406669fed7.png" alt="CowAgent" width="450px"/>

-**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆并不断成长。
+**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆和知识库并不断成长。

 CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企业微信应用、微信公众号、网页中使用，7×24小时运行于你的个人电脑或服务器中。

 <CardGroup cols={2}>
-  <Card title="GitHub" icon="github" href="https://github.com/zhayujie/chatgpt-on-wechat">
+  <Card title="GitHub" icon="github" href="https://github.com/zhayujie/CowAgent">
    开源代码仓库，欢迎 Star 和贡献
  </Card>
  <Card title="免部署在线体验" icon="cloud" href="https://link-ai.tech/cowagent/create">
@@ -22,21 +22,27 @@ CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、

 <CardGroup cols={2}>
  <Card title="复杂任务规划" icon="brain" href="/intro/architecture">
-    能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持通过工具操作访问文件、终端、浏览器、定时任务等系统资源。
+    能够理解复杂任务并自主规划执行，持续思考和调用各类工具和技能直到完成目标。
  </Card>
  <Card title="长期记忆" icon="database" href="/memory">
-    自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索。
+    三层记忆流转（上下文→天级记忆→全局记忆），每日梦境蒸馏整理，支持关键词及向量检索。
+  </Card>
+  <Card title="个人知识库" icon="book" href="/knowledge">
+    自动整理结构化知识，支持知识图谱可视化，通过交叉引用构建持续增长的知识网络。
  </Card>
  <Card title="技能系统" icon="puzzle-piece" href="/skills/index">
    实现了Skills创建和运行的引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发。
  </Card>
-  <Card title="多模态消息" icon="image" href="/channels/web">
-    支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作。
+  <Card title="工具系统" icon="wrench" href="/tools/index">
+    内置文件读写、终端执行、浏览器操作、定时任务、消息发送等工具，Agent 可自主调用工具完成复杂任务。
  </Card>
-  <Card title="多模型接入" icon="microchip" href="/models/index">
+  <Card title="命令系统" icon="terminal" href="/cli/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` 可以在网页端进行对话、配置、应用通道接入等操作。

--- a/docs/ja/README.md
+++ b/docs/ja/README.md
@@ -1,18 +1,19 @@
 <p align="center"><img src="https://github.com/user-attachments/assets/eca9a9ec-8534-4615-9e0f-96c5ac1d10a3" alt="CowAgent" width="550" /></p>

 <p align="center">
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/chatgpt-on-wechat" alt="Latest release"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/chatgpt-on-wechat" alt="License: MIT"></a>
-  <a href="https://github.com/zhayujie/chatgpt-on-wechat"><img src="https://img.shields.io/github/stars/zhayujie/chatgpt-on-wechat?style=flat-square" alt="Stars"></a> <br/>
-  [<a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/README.md">中文</a>] | [<a href="https://github.com/zhayujie/chatgpt-on-wechat/blob/master/docs/en/README.md">English</a>] | [日本語]
+  <a href="https://github.com/zhayujie/CowAgent/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/CowAgent" alt="Latest release"></a>
+  <a href="https://github.com/zhayujie/CowAgent/blob/master/LICENSE"><img src="https://img.shields.io/github/license/zhayujie/CowAgent" alt="License: MIT"></a>
+  <a href="https://github.com/zhayujie/CowAgent"><img src="https://img.shields.io/github/stars/zhayujie/CowAgent?style=flat-square" alt="Stars"></a> <br/>
+  [<a href="https://github.com/zhayujie/CowAgent/blob/master/README.md">中文</a>] | [<a href="https://github.com/zhayujie/CowAgent/blob/master/docs/en/README.md">English</a>] | [日本語]
 </p>

-**CowAgent** はLLMを搭載したAIスーパーアシスタントです。自律的なタスク計画、コンピュータや外部リソースの操作、Skillの作成・実行、長期記憶による継続的な成長が可能です。柔軟なモデル切り替えに対応し、テキスト・音声・画像・ファイルを処理でき、WeChat、Web、Feishu（飛書）、DingTalk（釘釘）、WeCom Bot（企業微信ボット）、WeComアプリ、WeChat公式アカウントに統合可能で、個人のPCやサーバー上で24時間365日稼働できます。
+**CowAgent** はLLMを搭載したAIスーパーアシスタントです。自律的なタスク計画、コンピュータや外部リソースの操作、Skillの作成・実行、長期記憶とパーソナルナレッジベースによる継続的な成長が可能です。柔軟なモデル切り替えに対応し、テキスト・音声・画像・ファイルを処理でき、WeChat、Web、Feishu（飛書）、DingTalk（釘釘）、WeCom Bot（企業微信ボット）、WeComアプリ、WeChat公式アカウントに統合可能で、個人のPCやサーバー上で24時間365日稼働できます。

 <p align="center">
  <a href="https://cowagent.ai/">🌐 ウェブサイト</a> &nbsp;·&nbsp;
  <a href="https://docs.cowagent.ai/en/intro/index">📖 ドキュメント</a> &nbsp;·&nbsp;
  <a href="https://docs.cowagent.ai/en/guide/quick-start">🚀 クイックスタート</a> &nbsp;·&nbsp;
+  <a href="https://skills.cowagent.ai/">🧩 Skill Hub</a> &nbsp;·&nbsp;
  <a href="https://link-ai.tech/cowagent/create">☁️ オンラインで試す</a>
 </p>

@@ -20,13 +21,15 @@

 > CowAgentは、すぐに使えるAIスーパーアシスタントであると同時に、高い拡張性を持つAgentフレームワークでもあります。新しいモデルインターフェース、チャネル、組み込みツール、Skillシステムを拡張することで、さまざまなカスタマイズニーズに柔軟に対応できます。

- ✅ **自律的タスク計画**: 複雑なタスクを理解し、自律的に実行計画を立て、目標達成までツールを呼び出しながら継続的に思考します。ツールを通じてファイル、ターミナル、ブラウザ、スケジューラなどのシステムリソースにアクセスできます。
- ✅ **長期記憶**: 会話の記憶をローカルファイルやデータベースに自動的に永続化します。コアメモリとデイリーメモリを含み、キーワード検索やベクトル検索に対応しています。
- ✅ **Skillシステム**: Skillの作成・実行エンジンを実装しており、複数の組み込みSkillを備え、自然言語での会話を通じたカスタムSkillの開発もサポートしています。
+- ✅ **自律的タスク計画**: 複雑なタスクを理解し、自律的に実行計画を立て、目標達成までツールを呼び出しながら継続的に思考します。
+- ✅ **長期記憶**: 会話の記憶をローカルファイルやデータベースに自動的に永続化します。コアメモリ、デイリーメモリ、Deep Dream 蒸留を含み、キーワード検索やベクトル検索に対応しています。
+- ✅ **パーソナルナレッジベース**: 構造化された知識を自動整理し、相互参照によるナレッジグラフを構築。Web での可視化ブラウジングと対話による管理をサポートします。
+- ✅ **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) プラットフォームを通じて、企業向けナレッジベース機能を統合できます。

 ## 免責事項

@@ -40,17 +43,21 @@

 ## 更新履歴

-> **2026.02.27:** [v2.0.2](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.2) — Webコンソールの全面刷新（ストリーミングチャット、モデル/Skill/メモリ/チャネル/スケジューラ/ログ管理）、マルチチャネル同時実行、セッション永続化、Gemini 3.1 Pro / Claude 4.6 Sonnet / Qwen3.5 Plusなど新モデル追加。
+> **2026.04.14:** [v2.0.6](https://github.com/zhayujie/CowAgent/releases/tag/2.0.6) — ナレッジベース、Deep Dream 記憶蒸留、スマートコンテキスト圧縮、Web コンソールアップグレード。

-> **2026.02.13:** [v2.0.1](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.1) — 組み込みWeb検索ツール、スマートコンテキストトリミング、ランタイム情報の動的更新、Windows互換性、スケジューラのメモリ喪失やFeishu接続問題などの修正。
+> **2026.04.01:** [v2.0.5](https://github.com/zhayujie/CowAgent/releases/tag/2.0.5) — Cow CLI、Skill Hubオープンソース化、ブラウザツール、WeCom Botスキャン作成など。

-> **2026.02.03:** [v2.0.0](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0) — マルチステップタスク計画、長期記憶、組み込みツール、Skillフレームワーク、新モデル、チャネル最適化を備えたAIスーパーアシスタントへの全面アップグレード。
+> **2026.02.27:** [v2.0.2](https://github.com/zhayujie/CowAgent/releases/tag/2.0.2) — Webコンソールの全面刷新（ストリーミングチャット、モデル/Skill/メモリ/チャネル/スケジューラ/ログ管理）、マルチチャネル同時実行、セッション永続化、Gemini 3.1 Pro / Claude 4.6 Sonnet / Qwen3.5 Plusなど新モデル追加。

-> **2025.05.23:** [v1.7.6](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.6) — Webチャネル最適化、AgentMeshマルチエージェントプラグイン、Baidu TTS、claude-4-sonnet/opus対応。
+> **2026.02.13:** [v2.0.1](https://github.com/zhayujie/CowAgent/releases/tag/2.0.1) — 組み込みWeb検索ツール、スマートコンテキストトリミング、ランタイム情報の動的更新、Windows互換性、スケジューラのメモリ喪失やFeishu接続問題などの修正。

-> **2025.04.11:** [v1.7.5](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.5) — wechatferryプロトコル、DeepSeekモデル、Tencent Cloud音声、ModelScope・Gitee-AI対応。
+> **2026.02.03:** [v2.0.0](https://github.com/zhayujie/CowAgent/releases/tag/2.0.0) — マルチステップタスク計画、長期記憶、組み込みツール、Skillフレームワーク、新モデル、チャネル最適化を備えたAIスーパーアシスタントへの全面アップグレード。

-> **2024.12.13:** [v1.7.4](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.4) — Gemini 2.0モデル、Webチャネル、メモリリーク修正。
+> **2025.05.23:** [v1.7.6](https://github.com/zhayujie/CowAgent/releases/tag/1.7.6) — Webチャネル最適化、AgentMeshマルチエージェントプラグイン、Baidu TTS、claude-4-sonnet/opus対応。
+
+> **2025.04.11:** [v1.7.5](https://github.com/zhayujie/CowAgent/releases/tag/1.7.5) — wechatferryプロトコル、DeepSeekモデル、Tencent Cloud音声、ModelScope・Gitee-AI対応。
+
+> **2024.12.13:** [v1.7.4](https://github.com/zhayujie/CowAgent/releases/tag/1.7.4) — Gemini 2.0モデル、Webチャネル、メモリリーク修正。

 全更新履歴: [リリースノート](https://docs.cowagent.ai/en/releases/overview)

@@ -60,21 +67,27 @@

 本プロジェクトは、インストール・設定・起動・管理をワンクリックで行えるスクリプトを提供しています：

+**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/cli/index)でサービスを管理できます。

 ### 手動インストール

 **1. プロジェクトのクローン**

 ```bash
-git clone https://github.com/zhayujie/chatgpt-on-wechat
-cd chatgpt-on-wechat/
+git clone https://github.com/zhayujie/CowAgent
+cd CowAgent/
 ```

 **2. 依存関係のインストール**
@@ -84,7 +97,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/cli/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 +123,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
@@ -125,7 +168,7 @@ sudo docker logs -f chatgpt-on-wechat
 | GLM | `glm-5-turbo` |
 | Kimi | `kimi-k2.5` |
 | Doubao | `doubao-seed-2-0-code-preview-260215` |
-| Qwen | `qwen3.5-plus` |
+| Qwen | `qwen3.6-plus` |
 | Claude | `claude-sonnet-4-6` |
 | Gemini | `gemini-3.1-pro-preview` |
 | OpenAI | `gpt-5.4` |
@@ -186,21 +229,22 @@ Coding Planは各プロバイダーが提供する月額サブスクリプショ

 ## 🔗 関連プロジェクト

+- [Cow Skill Hub](https://github.com/zhayujie/cow-skill-hub): AIエージェント向けのオープンSkillマーケットプレイス。CowAgent、OpenClaw、Claude Codeなどで利用可能なSkillの閲覧・検索・インストール・公開が可能。
 - [bot-on-anything](https://github.com/zhayujie/bot-on-anything): 軽量で高い拡張性を持つLLMアプリケーションフレームワーク。Slack、Telegram、Discord、Gmailなどに対応。
 - [AgentMesh](https://github.com/MinimalFuture/AgentMesh): エージェントチームの協調による複雑な問題解決のためのオープンソースのマルチエージェントフレームワーク。

 ## 🔎 よくある質問

-FAQ: <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
+FAQ: <https://github.com/zhayujie/CowAgent/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/CowAgent/blob/master/channel/feishu/feishu_channel.py)を参考にしてください。また、新しいSkillのコントリビューションも歓迎します。[Skill作成ドキュメント](https://docs.cowagent.ai/ja/skills/create)を参照するか、[Skill Hub](https://skills.cowagent.ai/submit)に提出してください。

 ## ✉ お問い合わせ

-PRやIssueの提出を歓迎します。🌟 Starでプロジェクトをサポートしてください。ご質問がある場合は、[FAQリスト](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs)を確認するか、[Issues](https://github.com/zhayujie/chatgpt-on-wechat/issues)を検索してください。
+PRやIssueの提出を歓迎します。🌟 Starでプロジェクトをサポートしてください。ご質問がある場合は、[FAQリスト](https://github.com/zhayujie/CowAgent/wiki/FAQs)を確認するか、[Issues](https://github.com/zhayujie/CowAgent/issues)を検索してください。

 ## 🌟 コントリビューター

-![cow contributors](https://contrib.rocks/image?repo=zhayujie/chatgpt-on-wechat&max=1000)
+![cow contributors](https://contrib.rocks/image?repo=zhayujie/CowAgent&max=1000)
--- a/docs/ja/channels/web.mdx
+++ b/docs/ja/channels/web.mdx
@@ -38,6 +38,16 @@ Web コンソールは CowAgent のデフォルトチャネルです。起動後

 <img width="850" src="https://cdn.link-ai.tech/doc/20260227180120.png" />

+#### マルチセッション管理
+
+チャット画面はマルチセッション管理に対応しています。すべてのセッション記録は SQLite データベースに永続的に保存されます：
+
+- **セッション一覧**：左側の履歴アイコンをクリックしてセッション一覧パネルを展開/折りたたみでき、スクロールですべての履歴セッションを読み込めます
+- **AI によるタイトル生成**：新しいセッションの最初のやり取りが完了すると、自動的にモデルを呼び出して短い要約タイトルを生成します
+- **新規セッション**：セッション一覧上部の「新しい会話」ボタン、または入力エリアの `+` ボタンをクリックして新しいセッションを作成します
+- **セッション削除**：セッション項目の削除ボタンをクリックし、確認後にそのセッションとすべてのメッセージを完全に削除します
+- **コンテキストクリア**：入力エリアのクリアボタンをクリックすると、現在のセッションに区切り線が挿入されます。区切り線より上のメッセージは表示されたままですが、モデルのコンテキストには含まれなくなります
+
 ### モデル管理

 設定ファイルを手動で編集せずに、オンラインでモデル設定を管理できます：
--- a/docs/ja/cli/general.mdx
+++ b/docs/ja/cli/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
+```
--- a/docs/ja/cli/index.mdx
+++ b/docs/ja/cli/index.mdx
@@ -0,0 +1,94 @@
+---
+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 ...)
+
+Memory & Knowledge:
+  memory    Memory distillation (dream)
+  knowledge View knowledge base stats and structure
+
+Others:
+  help      Show this help message
+  version   Show version
+```
+
+## チャットコマンド
+
+Web コンソールや接続されたチャネルの会話で `/` を入力すると、コマンドの候補が表示されます。使用可能なコマンド：
+
+| コマンド | 説明 |
+| --- | --- |
+| `/help` | コマンドヘルプを表示 |
+| `/status` | サービスの状態と設定を表示 |
+| `/config` | 実行時設定の表示・変更 |
+| `/skill` | スキル管理（インストール、アンインストール、有効化、無効化など） |
+| `/memory dream [N]` | 記憶蒸留を手動トリガー（デフォルト 3 日、最大 30） |
+| `/knowledge` | ナレッジベースの統計情報を表示 |
+| `/knowledge list` | ナレッジベースのディレクトリ構造を表示 |
+| `/knowledge on\|off` | ナレッジベースの有効化・無効化 |
+| `/context` | 現在のセッションのコンテキスト情報を表示 |
+| `/context clear` | 現在のセッションのコンテキストをクリア |
+| `/logs` | 最近のログを表示 |
+| `/version` | バージョン番号を表示 |
+
+<Tip>
+  `/start`、`/stop`、`/restart` などのサービス管理コマンドは、プロセス操作を伴うため、ターミナルでの使用を案内します。
+</Tip>
+
+## コマンド対応表
+
+| コマンド | ターミナル (`cow`) | チャット (`/`) |
+| --- | :---: | :---: |
+| help | ✓ | ✓ |
+| version | ✓ | ✓ |
+| status | ✓ | ✓ |
+| logs | ✓ | ✓ |
+| config | ✗ | ✓ |
+| context | — | ✓ |
+| memory（サブコマンド） | ✗ | ✓ |
+| knowledge（サブコマンド） | ✓ | ✓ |
+| skill（サブコマンド） | ✓ | ✓ |
+| start / stop / restart | ✓ | ✗ |
+| update | ✓ | ✗ |
+| install-browser | ✓ | ✗ |
+
+<Note>
+  `context` はターミナルではチャットでの使用を案内するのみです。`config` はチャットでのみ利用可能です。
+</Note>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
zhayujie	60e9d98d0a	feat: release 2.0.6	2026-04-14 12:37:53 +08:00
zhayujie	83f6625e0c	feat: release 2.0.6	2026-04-14 12:08:57 +08:00
zhayujie	acc09543b7	feat(dream): add memory dream cli and docs - New memory/deep-dream.mdx (zh/en/ja): memory flow, distillation rules, dream diary, manual trigger, safety mechanisms - Simplify long-term memory page, link to deep-dream for details - New cli/memory-knowledge.mdx (zh/en/ja): memory and knowledge commands - Move knowledge commands from general.mdx to memory-knowledge.mdx - Register new pages in docs.json navigation for all languages - Add /memory dream to cli/index.mdx command tables	2026-04-14 11:03:53 +08:00
zhayujie	94d8c7e366	feat(dream): add Dream Diary tab to memory management page - Backend: MemoryService supports category param (memory/dream), lists memory/dreams/*.md - Backend: MemoryContentHandler resolves dream files from memory/dreams/ directory - Frontend: add tab switcher (Memory Files / Dream Diary) matching knowledge tab style - Frontend: dream entries show purple "Dream" badge, empty state with moon icon - Cloud dispatch passes category param for consistency	2026-04-13 22:08:15 +08:00
zhayujie	ea1a0c8b3d	feat(memory): add Deep Dream module for daily memory distillation - Add Deep Dream: nightly distill daily memories → refined MEMORY.md + dream diary - Simplify flush prompt to daily-only, defer MEMORY.md maintenance to Deep Dream - Remove dead code (_append_to_main_memory) and fix fallback summary logic - Add shrinkage protection and input dedup for dream process - Ensure flush threads complete before dream starts - Update docs (zh/en/ja) with dream diary and distillation mechanism	2026-04-13 21:32:52 +08:00
zhayujie	7bc88c17e4	Merge branch 'master' of github.com:zhayujie/chatgpt-on-wechat	2026-04-13 20:13:30 +08:00
zhayujie	33cf1bc4c3	feat(memory): async LLM context summary injection on trim - Unified flush + context injection into a single async LLM call (flush_from_messages accepts context_summary_callback) - Fixed response parsing bug: handle generator returns and Claude-format dicts from bot.call_with_tools, which previously caused all LLM summaries to silently fail (falling back to rule-based extraction) - Removed standalone context summary prompts and methods; reuse the existing [DAILY]/[MEMORY] summarization pipeline - Updated docs (zh/en/ja) to reflect the new injection behavior	2026-04-13 20:13:05 +08:00
zhayujie	9402e63fe1	Merge pull request #2766 from zhayujie/feat-mulit-session feat(web): add multi-session management for web console	2026-04-13 18:51:07 +08:00
zhayujie	90e4d494b2	feat(web): add multi-session management for web console	2026-04-13 18:50:31 +08:00
zhayujie	da97e948ca	feat: refine memory recall/write prompts for better precision and proactivity	2026-04-13 18:02:06 +08:00
zhayujie	89a07e8e74	feat: add enable_thinking config to control deep reasoning on web console	2026-04-13 16:06:28 +08:00
zhayujie	3f3d0381e5	feat: update knowledge docs and fix claude error	2026-04-13 11:16:26 +08:00
zhayujie	3649499dba	fix: optimize the stability of network pre-checks	2026-04-13 10:35:38 +08:00
zhayujie	a989d088fd	Merge pull request #2764 from WilliamOnVoyage/fix/macos-timeout-fallback fix: Fix run.sh for MacOS via add timeout fallback	2026-04-13 10:21:44 +08:00
Moliang Zhou	f79a915136	fix: add timeout fallback for macOS compatibility The `timeout` command (GNU Coreutils) is not available by default on macOS, causing the installation script to fail with 'timeout: command not found' during git clone. This adds a shell function fallback that: - Uses `gtimeout` if Homebrew coreutils is installed - Otherwise skips the timeout and runs the command directly	2026-04-12 11:18:44 -07:00
zhayujie	12e8c3d449	Merge pull request #2763 from zhayujie/feat-web-console-upgrade feat(web): support scheduler push messages and enrich welcome screen	2026-04-12 21:20:34 +08:00
zhayujie	4f7064575e	feat(web): support scheduler push messages and enrich welcome screen - Expand welcome screen from 3 to 6 example cards covering core capabilities - Enable background polling on page load so scheduler task notifications are received in real-time - Fix duplicate poll loops via generation-based cancellation, reduce poll frequency to 5s/10s - Ensure equal card height and adjust layout position for better visual balance	2026-04-12 21:19:50 +08:00
zhayujie	070df826f1	Merge pull request #2762 from zhayujie/feat-web-console-upgrade feat(web): add password protection for web console	2026-04-12 20:38:45 +08:00
zhayujie	fbe48a4b4e	feat(web): add password protection for web console - Add `web_password` config to enable login authentication - Use stateless HMAC-signed token (survives restart, invalidates on password change) - Add `web_session_expire_days` config (default 30 days) - Protect all API endpoints with auth check (401 on failure) - Add login page UI with auto-redirect on session expiry - Add password management in config page (masked display, inline edit) - Add tooltip hints for Agent config fields - Update default agent_max_context_turns to 20, agent_max_steps to 20 - Update docs and docker-compose.yml	2026-04-12 20:37:04 +08:00
zhayujie	4dd497fb6d	fix: run.ps1 git clone in windows	2026-04-12 17:52:37 +08:00
zhayujie	907882c0a7	fix: git clone pre-check	2026-04-12 17:36:45 +08:00
zhayujie	d36d5aee3f	feat: rename repository name from chatgpt-on-wechat to CowAgent - Update GitHub URLs in README.md (badges, release links, clone address, wiki, issues, contributors) - Add project rename notice with SEO keywords and git remote update command - Update docs/docs.json GitHub links - Update all docs (zh/en/ja) across guide, intro, models, releases, skills - Update run.sh and scripts/run.ps1 clone URLs and directory names - Docker image name (zhayujie/chatgpt-on-wechat) kept unchanged for compatibility	2026-04-12 17:09:07 +08:00
zhayujie	c6824e5f5e	fix: add legacy-cgi dependency for Python 3.13+ #2758 Add conditional dependency `legacy-cgi` for Python 3.13+ to resolve `web.py` installation failure caused by the removal of the `cgi` module (PEP 594). Thanks @sha156 for reporting.	2026-04-12 16:49:00 +08:00
zhayujie	199c21eede	Merge pull request #2761 from zhayujie/feat-knowledge feat: personal knowledge base system	2026-04-12 16:47:07 +08:00
zhayujie	5162da5654	Merge branch 'master' into feat-knowledge	2026-04-12 16:46:38 +08:00
zhayujie	a1d82f6193	feat(knowledge): add cli and update docs	2026-04-12 16:39:06 +08:00
zhayujie	ea78e3d0c6	feat(knowledge): document link supports jumping to view	2026-04-11 20:16:43 +08:00
zhayujie	3497f00cb4	Merge pull request #2759 from zhayujie/feat-multimodel feat(vision): prioritize main model for image recognition	2026-04-11 19:55:15 +08:00
zhayujie	5355d45031	Merge pull request #2756 from octo-patch/feature/add-minimax-m2.7-highspeed-tts feat: add MiniMax-M2.7-highspeed model and MiniMax TTS support	2026-04-11 19:54:03 +08:00
zhayujie	26693acc3f	feat(vision): prioritize main model for image recognition with multi-provider fallback - Add call_vision method to all bot implementations (DashScope, Claude, Gemini, ZhipuAI, MiniMax, Doubao, Moonshot, OpenAICompatibleBot) using each vendor's native multimodal API format - Remove call_with_tools/call_vision from Bot base class to fix MRO shadowing issue with OpenAICompatibleBot mixin - Refactor vision tool provider resolution: MainModel → other configured models (auto-discovered) → OpenAI → LinkAI, with automatic fallback - Return actual model name used in call_vision responses - Sync config.json API keys to .env bidirectionally on startup - Fix bot instance cache to detect bot_type/use_linkai config changes - Add SSE reconnection support for web console - Preserve image path hints in Gemini text for correct vision tool calls - Update docs/tools/vision.mdx	2026-04-11 19:46:11 +08:00
zhayujie	76e9fef3b2	feat(knowledge): add file list and graph in web channel	2026-04-11 19:02:55 +08:00
octo-patch	c34308cbd4	feat: add MiniMax-M2.7-highspeed model and MiniMax TTS support - Add MiniMax-M2.7-highspeed constant to const.py and MODEL_LIST - Update MinimaxBot default model from MiniMax-M2.1 to MiniMax-M2.7 - Add MinimaxVoice TTS provider (voice/minimax/minimax_voice.py) - Supports speech-2.8-hd and speech-2.8-turbo models - SSE streaming with hex-decoded audio chunks - Reuses MINIMAX_API_KEY - Register MinimaxVoice in voice factory - Add unit tests (14 tests, all passing) - Update README with MiniMax-M2.7-highspeed and TTS configuration	2026-04-11 17:03:44 +08:00
zhayujie	5a10476010	feat: add knowledge switch and cli	2026-04-11 16:44:25 +08:00
zhayujie	46e80dceec	Merge pull request #2755 from 6vision/fix/generic-file-send fix: send generic file types (tar.gz, zip, etc.) as FILE instead of TEXT	2026-04-11 16:36:34 +08:00
6vision	90d1835353	fix: send generic file types (tar.gz, zip, etc.) as FILE instead of TEXT Previously, files with extensions not in the known categories (image, document, video, audio) fell through to a fallback that returned ReplyType.TEXT, causing the file to never actually be sent to the user. Now the fallback uses ReplyType.FILE so all file types are delivered. Made-with: Cursor	2026-04-11 15:45:34 +08:00
zhayujie	845fadd0aa	fix(knowledge): modify knowledge skill	2026-04-10 18:22:54 +08:00
zhayujie	5748ded52c	feat(knowledge): change knowledge base to index-driven self-organizing structure	2026-04-10 16:06:04 +08:00
zhayujie	6a737fb734	feat: display thinking content in web console	2026-04-10 15:07:23 +08:00
zhayujie	3cd92ccda3	feat: add port config	2026-04-09 21:29:53 +08:00
zhayujie	54e81aba11	feat(memory+knowledge): add knowledge wiki system and Light Dream memory extraction - Add knowledge/ directory structure and knowledge-wiki skill for structured knowledge accumulation - Auto-inject MEMORY.md into system prompt with truncation (last 200 lines) - Light Dream: extend flush_memory to extract long-term memories into MEMORY.md with date stamps - Add mandatory knowledge auto-write rules in system prompt (no user confirmation needed) - Expand MemoryManager.sync() to index knowledge/ files for vector search - Update RULE.md template with workspace conventions and knowledge guidelines	2026-04-09 21:22:43 +08:00
zhayujie	d86cb4ded6	fix(weixin): update weixin channel version	2026-04-09 09:55:07 +08:00
zhayujie	4d5375f6d6	fix(win): add Windows platform hint in bash tool description	2026-04-08 16:54:26 +08:00
zhayujie	424557fedb	fix(win): use PowerShell instead of cmd.exe	2026-04-08 16:50:45 +08:00
zhayujie	89251e603f	fix(win): use PowerShell instead of cmd.exe for bash tool on Windows	2026-04-08 16:18:56 +08:00
zhayujie	a653ed07eb	fix(win): defer pip install to a helper bat after cow.exe exits	2026-04-08 15:31:03 +08:00
zhayujie	ad86deb014	fix: prioritize using a custom master model for vision	2026-04-08 15:16:59 +08:00
zhayujie	9525dc7584	fix: avoid stale cow.exe on Windows by spawing fresh process	2026-04-08 12:07:18 +08:00
zhayujie	cd31dd27fd	fix: increase web console capacity and add frontend retry	2026-04-08 11:48:27 +08:00
zhayujie	360e3670eb	feat(browser): detect implicit interactive elements	2026-04-07 01:41:14 +08:00
zhayujie	8dabe3b4c8	fix: remove install-browser cmd display in /help	2026-04-04 23:28:57 +08:00
zhayujie	443e0c2806	feat: show video in web channel	2026-04-03 17:09:38 +08:00
zhayujie	9cc173cc4d	fix: use dynamic model name in system prompt runtime info	2026-04-02 17:01:56 +08:00
zhayujie	b5f33e5ecd	feat: support qwen3.6-plus	2026-04-02 16:46:58 +08:00
zhayujie	40dfc6860f	fix: skill list showing sub-skills inside collection	2026-04-02 11:47:24 +08:00
zhayujie	1c02a04423	fix: handle error when printing QR code on Windows GBK terminals	2026-04-01 17:23:57 +08:00
zhayujie	de0e45070c	chore: remove conflicting dependency	2026-04-01 17:19:15 +08:00
zhayujie	c169cc7d74	fix: remove conflicting dependency	2026-04-01 17:12:15 +08:00
zhayujie	cd62ad76f6	fix: cow CLI support python3.7	2026-04-01 16:51:23 +08:00
zhayujie	dd25b0fb5b	feat: refine system prompt style and tone guidance	2026-04-01 16:24:41 +08:00
zhayujie	a38b22a6a2	docs: update docs	2026-04-01 15:31:41 +08:00
zhayujie	830b8f2971	feat: release 2.0.5	2026-04-01 15:01:53 +08:00
zhayujie	b058af122c	feat: release 2.0.5	2026-04-01 12:24:21 +08:00
zhayujie	174ee0cafc	fix(security): prevent path traversal in memory content API	2026-04-01 10:03:58 +08:00
zhayujie	1c336380c0	docs: update release doc	2026-03-31 22:30:31 +08:00
zhayujie	3068880413	feat: save skill display name when downloading	2026-03-31 21:43:57 +08:00
zhayujie	be596681e5	Merge pull request #2735 from zhayujie/feat-wecom-bot-qrcode feat(wecom_bot): add Wecom Bot QR code scan auth	2026-03-31 21:28:39 +08:00
zhayujie	66b71c50e9	feat(wecom_bot): add Wecom Bot QR code scan auth	2026-03-31 21:27:50 +08:00
zhayujie	8744810b25	fix: skill install timeout	2026-03-31 20:47:59 +08:00
zhayujie	7f94d37c2e	fix: auto-install font in browser	2026-03-31 20:20:13 +08:00
zhayujie	6d9b7baeb4	fix(weixin): file send failed	2026-03-31 18:14:49 +08:00
zhayujie	4470d4c352	fix: reduce docker image size	2026-03-31 16:56:27 +08:00
zhayujie	d2a462a279	fix: add apt source in docker file	2026-03-31 16:34:47 +08:00
zhayujie	14ff2a15e7	fix(cli): cow cli in docker chat	2026-03-31 16:25:47 +08:00
zhayujie	6d1369900e	feat: add source args in docker building	2026-03-31 16:06:45 +08:00
zhayujie	1f17ebe69e	feat: add browser install in docker image	2026-03-31 16:05:05 +08:00
zhayujie	1ae2918064	feat: support install browser in chat	2026-03-31 15:15:17 +08:00
zhayujie	b6571e5cad	fix: browser resource optimization	2026-03-30 21:39:38 +08:00
zhayujie	7549d48cf1	fix: browser thread bug	2026-03-30 21:27:08 +08:00
zhayujie	00353dd0cb	feat: support skill hub mirror	2026-03-30 18:46:02 +08:00
zhayujie	afd947195d	fix(cli): support skill mirror install	2026-03-30 16:36:17 +08:00
zhayujie	e57ef37167	fix: prevent phantom mouseover from hijacking slash menu	2026-03-30 11:52:05 +08:00
zhayujie	ef33a93654	Merge pull request #2731 from zkjqd/fix/slash-menu-click Fix the issue where the shortcut command in the input box cannot be clicked to select events	2026-03-30 11:40:06 +08:00
zhayujie	61732aecfc	Merge pull request #2721 from yrk111222/feat/modelscope-update Feat/modelscope update	2026-03-30 11:39:50 +08:00
zkjqd	6764c05c3f	input-slash-click	2026-03-30 11:20:03 +08:00
zhayujie	fa149cf4aa	fix(browser): multi-thread browser instance bug	2026-03-30 00:57:19 +08:00
zhayujie	e4f9697d06	feat(browser): install font in linux	2026-03-29 23:52:51 +08:00
zhayujie	da061450e5	fix: github skill install cmd	2026-03-29 19:23:47 +08:00
zhayujie	d09ae49287	feat(browser): auto-snapshot on navigate, screenshot prompt guidance Browser tool enhancements: - Navigate action now auto-includes snapshot result, saving one LLM round-trip - Wait for networkidle + 800ms after navigation for SPA/JS-rendered pages - Prompt guides agent to screenshot key results and ask user for login/CAPTCHA help - Fixed playwright version pinned to 1.52.0; mirror fallback to official CDN on failure Web console file/image support: - SSE real-time push for images and files via on_event (file_to_send) - Added /api/file endpoint to serve local files for web preview - Frontend renders images in media-content container (survives delta/done overwrites) - File attachment cards with download links; RFC 5987 encoding for non-ASCII filenames Tool workspace fix: - Inject workspace_dir as cwd into send and browser tools (previously only file tools) - Screenshots now save to ~/cow/tmp/ instead of project directory	2026-03-29 19:09:11 +08:00
zhayujie	511ee0bbaf	fix: windows PowerShell script	2026-03-29 18:28:50 +08:00
zhayujie	3cb5a0fbd6	docs: add CLI system docs	2026-03-29 17:57:12 +08:00
zhayujie	e06925ab85	fix: optimize browser install cli and fix vision prompt	2026-03-29 15:19:59 +08:00
zhayujie	184634e4e7	fix(cli): browser install failed	2026-03-29 15:14:07 +08:00
zhayujie	843c2d02cc	Merge branch 'master' of github.com:zhayujie/chatgpt-on-wechat	2026-03-29 15:09:37 +08:00
zhayujie	9dc9987d56	Merge pull request #2727 from zhayujie/feat-browser-tool feat: add browser tool	2026-03-29 14:59:39 +08:00
yrk	294e380288	update model_list	2026-03-24 11:00:55 +08:00
yrk	4c1c42efac	feat: update modelscope bot	2026-03-24 10:43:45 +08:00
@@ -1 +1 @@
 .0.4
 .0.6