Merge branch 'main' into remove-wecom-channel-17101495203808413994

2026-03-13 16:49:34 -04:00 · 2026-03-13 16:49:34 -04:00 · 4df9a422a9
commit 4df9a422a9
parent c9ddb829e0 7074e824b9
57 changed files with 1937 additions and 3710 deletions
--- a/.env.example
+++ b/.env.example
@ -9,10 +9,6 @@
 # ── Chat Channel ──────────────────────────
 # TELEGRAM_BOT_TOKEN=123456:ABC...
 # DISCORD_BOT_TOKEN=xxx
-# Feishu (飞书)
-# PICOCLAW_CHANNELS_FEISHU_APP_ID=cli_xxx
-# PICOCLAW_CHANNELS_FEISHU_APP_SECRET=xxx
-# PICOCLAW_CHANNELS_FEISHU_RANDOM_REACTION_EMOJI=Typing,OneSecond

 # ── Web Search (optional) ────────────────
 # BRAVE_SEARCH_API_KEY=BSA...
--- a/.jules/bolt.md
+++ b/.jules/bolt.md
@ -1,3 +1,6 @@
 ## 2024-05-24 - Single Pass String Iteration for Token Estimation
 **Learning:** `utf8.RuneCountInString(msg)` performs a full iteration over the string. If the string needs to be iterated over again (e.g., `for _, r := range msg`) to check specific rune properties, this results in two full passes over the string.
 **Action:** Always count the total number of runes manually within the existing `for range` loop when a subsequent full iteration of the string is already required. This essentially halves the execution time.
+## 2024-05-25 - Efficient String Building in Loops
+**Learning:** In Go, string concatenation (`+=`) in a loop leads to $O(N^2)$ complexity due to immutability. Using `strings.Builder` provides $O(N)$ efficiency. Additionally, `fmt.Fprintf` has overhead due to format string parsing; direct `sb.WriteString` calls are significantly faster.
+**Action:** Use `strings.Builder` for building strings in loops and prefer direct `WriteString` calls over `fmt.Fprintf` for maximum performance in hot paths.
--- a/.jules/sentinel.md
+++ b/.jules/sentinel.md
@ -0,0 +1,4 @@
+## 2025-02-28 - [Medium] Fix Missing HTTP Server Timeouts
+**Vulnerability:** Go's standard `http.ListenAndServe` and unconfigured `http.Server` instances lack default timeouts for reading headers, reading bodies, and writing responses.
+**Learning:** These default settings leave the application vulnerable to resource exhaustion and Denial of Service (DoS) attacks, such as Slowloris, because malicious clients can slowly send data and tie up server connections indefinitely.
+**Prevention:** Always instantiate `http.Server` explicitly and set `ReadHeaderTimeout`, `ReadTimeout`, `WriteTimeout`, and (optionally) `IdleTimeout` to reasonable values based on the expected request sizes and latencies.
--- a/README.fr.md
+++ b/README.fr.md
@ -802,14 +802,6 @@ picoclaw agent -m "Bonjour, comment ça va ?"
    "whatsapp": {
      "enabled": false
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    },
    "qq": {
      "enabled": false,
      "app_id": "",
--- a/README.ja.md
+++ b/README.ja.md
@ -753,14 +753,6 @@ HEARTBEAT_OK 応答         ユーザーが直接結果を受け取る
    "whatsapp": {
      "enabled": false
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    }
  },
  "tools": {
    "web": {
--- a/README.md
+++ b/README.md
@ -326,7 +326,7 @@ That's it! You have a working AI assistant in 2 minutes.

 Talk to your picoclaw through Telegram, Discord, WhatsApp, Matrix, QQ, DingTalk, LINE, or WeCom

-> **Note**: All webhook-based channels (LINE, WeCom, etc.) are served on a single shared Gateway HTTP server (`gateway.host`:`gateway.port`, default `127.0.0.1:18790`). There are no per-channel ports to configure. Note: Feishu uses WebSocket/SDK mode and does not use the shared HTTP webhook server.
+> **Note**: All webhook-based channels (LINE, WeCom, etc.) are served on a single shared Gateway HTTP server (`gateway.host`:`gateway.port`, default `127.0.0.1:18790`). There are no per-channel ports to configure.

 | Channel      | Setup                              |
 | ------------ | ---------------------------------- |
@ -1205,14 +1205,6 @@ picoclaw agent -m "Hello"
      "session_store_path": "",
      "allow_from": []
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    },
    "qq": {
      "enabled": false,
      "app_id": "",
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -796,14 +796,6 @@ picoclaw agent -m "Ola, como vai?"
    "whatsapp": {
      "enabled": false
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    },
    "qq": {
      "enabled": false,
      "app_id": "",
--- a/README.vi.md
+++ b/README.vi.md
@ -768,14 +768,6 @@ picoclaw agent -m "Xin chào"
    "whatsapp": {
      "enabled": false
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    },
    "qq": {
      "enabled": false,
      "app_id": "",
--- a/README.zh.md
+++ b/README.zh.md
@ -293,7 +293,7 @@ picoclaw agent -m "2+2 等于几？"

 PicoClaw 支持多种聊天平台，使您的 Agent 能够连接到任何地方。

-> **注意**: 所有 Webhook 类渠道（LINE、WeCom 等）均挂载在同一个 Gateway HTTP 服务器上（`gateway.host`:`gateway.port`，默认 `127.0.0.1:18790`），无需为每个渠道单独配置端口。注意：飞书（Feishu）使用 WebSocket/SDK 模式，不通过该共享 HTTP webhook 服务器接收消息。
+> **注意**: 所有 Webhook 类渠道（LINE、WeCom 等）均挂载在同一个 Gateway HTTP 服务器上（`gateway.host`:`gateway.port`，默认 `127.0.0.1:18790`），无需为每个渠道单独配置端口。

 ### 核心渠道

@ -305,7 +305,6 @@ PicoClaw 支持多种聊天平台，使您的 Agent 能够连接到任何地方
 | **Matrix**           | ⭐⭐ 中等   | 联邦协议，支持自建 homeserver 与公开服务器 | [查看文档](docs/channels/matrix/README.zh.md)                                                                  |
 | **QQ**               | ⭐⭐ 中等   | 官方机器人 API，适合国内社群              | [查看文档](docs/channels/qq/README.zh.md)                                                                       |
 | **钉钉 (DingTalk)**  | ⭐⭐ 中等   | Stream 模式无需公网，企业办公首选         | [查看文档](docs/channels/dingtalk/README.zh.md)                                                                 |
-| **飞书 (Feishu)**    | ⭐⭐⭐ 较难 | 企业级协作，功能丰富                      | [查看文档](docs/channels/feishu/README.zh.md)                                                                   |
 | **Line**             | ⭐⭐⭐ 较难 | 需要 HTTPS Webhook                        | [查看文档](docs/channels/line/README.zh.md)                                                                     |
 | **OneBot**           | ⭐⭐ 中等   | 兼容 NapCat/Go-CQHTTP，社区生态丰富       | [查看文档](docs/channels/onebot/README.zh.md)                                                                   |
 | **MaixCam**          | ⭐ 简单     | 专为 AI 摄像头设计的硬件集成通道          | [查看文档](docs/channels/maixcam/README.zh.md)                                                                  |
@ -774,14 +773,6 @@ picoclaw agent -m "你好"
    "whatsapp": {
      "enabled": false
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    },
    "qq": {
      "enabled": false,
      "app_id": "",
--- a/ROADMAP.md
+++ b/ROADMAP.md
@ -48,7 +48,7 @@


 * **Channel**
-  * **IM Matrix**: QQ, WeChat (Work), DingTalk, Feishu (Lark), Telegram, Discord, WhatsApp, LINE, Slack, Email, KOOK, Signal, ...
+  * **IM Matrix**: QQ, WeChat (Work), DingTalk, Telegram, Discord, WhatsApp, LINE, Slack, Email, KOOK, Signal, ...
  * **Standards**: Support for the **OneBot** protocol.
  * [**attachment**](https://github.com/sipeed/picoclaw/issues/348): Native handling of images, audio, and video attachments.

--- a/cmd/picoclaw-launcher-tui/internal/ui/app.go
+++ b/cmd/picoclaw-launcher-tui/internal/ui/app.go
@ -138,7 +138,6 @@ func (s *appState) countChannels() (enabled int, total int) {
 		c.QQ.Enabled,
 		c.MaixCam.Enabled,
 		c.WhatsApp.Enabled,
-		c.Feishu.Enabled,
 		c.DingTalk.Enabled,
 		c.Slack.Enabled,
 		c.Matrix.Enabled,
@ -436,7 +435,7 @@ func (s *appState) isActiveModelValid() bool {
 func (s *appState) hasEnabledChannel() bool {
 	c := s.config.Channels
 	return c.Telegram.Enabled || c.Discord.Enabled || c.QQ.Enabled || c.MaixCam.Enabled ||
-		c.WhatsApp.Enabled || c.Feishu.Enabled || c.DingTalk.Enabled || c.Slack.Enabled ||
+		c.WhatsApp.Enabled || c.DingTalk.Enabled || c.Slack.Enabled ||
 		c.Matrix.Enabled || c.LINE.Enabled || c.OneBot.Enabled
 }

--- a/cmd/picoclaw-launcher-tui/internal/ui/channel.go
+++ b/cmd/picoclaw-launcher-tui/internal/ui/channel.go
@ -42,12 +42,6 @@ func (s *appState) buildChannelMenuItems() []MenuItem {
 			s.config.Channels.WhatsApp.Enabled,
 			func() { s.push("channel-whatsapp", s.whatsappForm()) },
 		),
-		channelItem(
-			"Feishu",
-			"Feishu bot settings",
-			s.config.Channels.Feishu.Enabled,
-			func() { s.push("channel-feishu", s.feishuForm()) },
-		),
 		channelItem(
 			"DingTalk",
 			"DingTalk bot settings",
@ -157,25 +151,6 @@ func (s *appState) whatsappForm() tview.Primitive {
 	return wrapWithBack(form, s)
 }

-func (s *appState) feishuForm() tview.Primitive {
-	cfg := &s.config.Channels.Feishu
-	form := baseChannelForm("Feishu", cfg.Enabled, s.makeChannelOnEnabled(&cfg.Enabled))
-	form.AddInputField("App ID", cfg.AppID, 64, nil, func(text string) {
-		cfg.AppID = strings.TrimSpace(text)
-	})
-	form.AddInputField("App Secret", cfg.AppSecret, 128, nil, func(text string) {
-		cfg.AppSecret = strings.TrimSpace(text)
-	})
-	form.AddInputField("Encrypt Key", cfg.EncryptKey, 128, nil, func(text string) {
-		cfg.EncryptKey = strings.TrimSpace(text)
-	})
-	form.AddInputField("Verification Token", cfg.VerificationToken, 128, nil, func(text string) {
-		cfg.VerificationToken = strings.TrimSpace(text)
-	})
-	addAllowFromField(form, &cfg.AllowFrom)
-	return wrapWithBack(form, s)
-}
-
 func (s *appState) dingtalkForm() tview.Primitive {
 	cfg := &s.config.Channels.DingTalk
 	form := baseChannelForm("DingTalk", cfg.Enabled, s.makeChannelOnEnabled(&cfg.Enabled))
--- a/cmd/picoclaw/internal/gateway/helpers.go
+++ b/cmd/picoclaw/internal/gateway/helpers.go
@ -15,7 +15,6 @@ import (
 	"jane/pkg/channels"
 	_ "jane/pkg/channels/dingtalk"
 	_ "jane/pkg/channels/discord"
-	_ "jane/pkg/channels/feishu"
 	_ "jane/pkg/channels/irc"
 	_ "jane/pkg/channels/line"
 	_ "jane/pkg/channels/maixcam"
--- a/cmd/picoclaw/internal/helpers.go
+++ b/cmd/picoclaw/internal/helpers.go
@ -29,21 +29,3 @@ func GetConfigPath() string {
 func LoadConfig() (*config.Config, error) {
 	return config.LoadConfig(GetConfigPath())
 }
-
-// FormatVersion returns the version string with optional git commit
-// Deprecated: Use pkg/config.FormatVersion instead
-func FormatVersion() string {
-	return config.FormatVersion()
-}
-
-// FormatBuildInfo returns build time and go version info
-// Deprecated: Use pkg/config.FormatBuildInfo instead
-func FormatBuildInfo() (string, string) {
-	return config.FormatBuildInfo()
-}
-
-// GetVersion returns the version string
-// Deprecated: Use pkg/config.GetVersion instead
-func GetVersion() string {
-	return config.GetVersion()
-}
--- a/config/config.example.json
+++ b/config/config.example.json
@ -96,16 +96,6 @@
      "allow_from": [],
      "reasoning_channel_id": ""
    },
-    "feishu": {
-      "enabled": false,
-      "app_id": "",
-      "app_secret": "",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": [],
-      "reasoning_channel_id": "",
-      "random_reaction_emoji": []
-    },
    "dingtalk": {
      "enabled": false,
      "client_id": "YOUR_CLIENT_ID",
--- a/docs/channels/feishu/README.zh.md
+++ b/docs/channels/feishu/README.zh.md
@ -1,39 +0,0 @@
-# 飞书
-
-飞书（国际版名称：Lark）是字节跳动旗下的企业协作平台。它通过事件驱动的 Webhook 同时支持中国和全球市场。
-
-## 配置
-
-```json
-{
-  "channels": {
-    "feishu": {
-      "enabled": true,
-      "app_id": "cli_xxx",
-      "app_secret": "xxx",
-      "encrypt_key": "",
-      "verification_token": "",
-      "allow_from": []
-    }
-  }
-}
-```
-
-| 字段               | 类型   | 必填 | 描述                             |
-| ------------------ | ------ | ---- | -------------------------------- |
-| enabled            | bool   | 是   | 是否启用飞书频道                 |
-| app_id             | string | 是   | 飞书应用的 App ID(以cli\_开头)   |
-| app_secret         | string | 是   | 飞书应用的 App Secret            |
-| encrypt_key        | string | 否   | 事件回调加密密钥                 |
-| verification_token | string | 否   | 用于Webhook事件验证的Token       |
-| allow_from         | array  | 否   | 用户ID白名单，空表示所有用户   |
-| random_reaction_emoji | array | 否   | 随机添加的表情列表，空则使用默认 "Pin" |
-
-## 设置流程
-
-1. 前往 [飞书开放平台](https://open.feishu.cn/)创建应用程序
-2. 获取 App ID 和 App Secret
-3. 配置事件订阅和Webhook URL
-4. 设置加密(可选,生产环境建议启用)
-5. 将 App ID、App Secret、Encrypt Key 和 Verification Token(如果启用加密) 填入配置文件中
-6. 自定义你希望 PicoClaw react 你消息时的表情（可选, Reference URL: [Feishu Emoji List](https://open.larkoffice.com/document/server-docs/im-v1/message-reaction/emojis-introduce))
--- a/go.mod
+++ b/go.mod
@ -15,7 +15,6 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/h2non/filetype v1.1.3
-	github.com/larksuite/oapi-sdk-go/v3 v3.5.3
 	github.com/mdp/qrterminal/v3 v3.2.1
 	github.com/modelcontextprotocol/go-sdk v1.3.1
 	github.com/mymmrac/telego v1.6.0
@ -80,7 +79,6 @@ require (
 	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/github/copilot-sdk/go v0.1.23
 	github.com/go-resty/resty/v2 v2.17.1 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/jsonschema-go v0.4.2 // indirect
 	github.com/grbit/go-json v0.11.0 // indirect
 	github.com/klauspost/compress v1.18.4 // indirect
--- a/patch_llm.patch
+++ b/patch_llm.patch
@ -1,139 +0,0 @@
--- pkg/agent/loop.go
-+++ pkg/agent/loop.go
-@@ -910,121 +910,13 @@
-				"tools_json":    formatToolsForLog(providerToolDefs),
-			})
-
-		// Call LLM with fallback chain if multiple candidates are configured.
-		var response *providers.LLMResponse
-		var err error
-
-		llmOpts := map[string]any{
-			"max_tokens":       agent.MaxTokens,
-			"temperature":      agent.Temperature,
-			"prompt_cache_key": agent.ID,
-		}
-		// parseThinkingLevel guarantees ThinkingOff for empty/unknown values,
-		// so checking != ThinkingOff is sufficient.
-		if agent.ThinkingLevel != ThinkingOff {
-			if tc, ok := agent.Provider.(providers.ThinkingCapable); ok && tc.SupportsThinking() {
-				llmOpts["thinking_level"] = string(agent.ThinkingLevel)
-			} else {
-				logger.WarnCF("agent", "thinking_level is set but current provider does not support it, ignoring",
-					map[string]any{"agent_id": agent.ID, "thinking_level": string(agent.ThinkingLevel)})
-			}
-		}
-
-		callLLM := func() (*providers.LLMResponse, error) {
-			if len(activeCandidates) > 1 && al.fallback != nil {
-				fbResult, fbErr := al.fallback.Execute(
-					ctx,
-					activeCandidates,
-					func(ctx context.Context, provider, model string) (*providers.LLMResponse, error) {
-						return agent.Provider.Chat(ctx, messages, providerToolDefs, model, llmOpts)
-					},
-				)
-				if fbErr != nil {
-					return nil, fbErr
-				}
-				if fbResult.Provider != "" && len(fbResult.Attempts) > 0 {
-					logger.InfoCF(
-						"agent",
-						fmt.Sprintf("Fallback: succeeded with %s/%s after %d attempts",
-							fbResult.Provider, fbResult.Model, len(fbResult.Attempts)+1),
-						map[string]any{"agent_id": agent.ID, "iteration": iteration},
-					)
-				}
-				return fbResult.Response, nil
-			}
-			return agent.Provider.Chat(ctx, messages, providerToolDefs, activeModel, llmOpts)
-		}
-
-		// Retry loop for context/token errors
-		maxRetries := 2
-		for retry := 0; retry <= maxRetries; retry++ {
-			response, err = callLLM()
-			if err == nil {
-				break
-			}
-
-			errMsg := strings.ToLower(err.Error())
-
-			// Check if this is a network/HTTP timeout — not a context window error.
-			isTimeoutError := errors.Is(err, context.DeadlineExceeded) ||
-				strings.Contains(errMsg, "deadline exceeded") ||
-				strings.Contains(errMsg, "client.timeout") ||
-				strings.Contains(errMsg, "timed out") ||
-				strings.Contains(errMsg, "timeout exceeded")
-
-			// Detect real context window / token limit errors, excluding network timeouts.
-			isContextError := !isTimeoutError && (strings.Contains(errMsg, "context_length_exceeded") ||
-				strings.Contains(errMsg, "context window") ||
-				strings.Contains(errMsg, "maximum context length") ||
-				strings.Contains(errMsg, "token limit") ||
-				strings.Contains(errMsg, "too many tokens") ||
-				strings.Contains(errMsg, "max_tokens") ||
-				strings.Contains(errMsg, "invalidparameter") ||
-				strings.Contains(errMsg, "prompt is too long") ||
-				strings.Contains(errMsg, "request too large"))
-
-			if isTimeoutError && retry < maxRetries {
-				backoff := time.Duration(retry+1) * 5 * time.Second
-				logger.WarnCF("agent", "Timeout error, retrying after backoff", map[string]any{
-					"error":   err.Error(),
-					"retry":   retry,
-					"backoff": backoff.String(),
-				})
-				time.Sleep(backoff)
-				continue
-			}
-
-			if isContextError && retry < maxRetries {
-				logger.WarnCF(
-					"agent",
-					"Context window error detected, attempting compression",
-					map[string]any{
-						"error": err.Error(),
-						"retry": retry,
-					},
-				)
-
-				if retry == 0 && !constants.IsInternalChannel(opts.Channel) {
-					al.bus.PublishOutbound(ctx, bus.OutboundMessage{
-						Channel: opts.Channel,
-						ChatID:  opts.ChatID,
-						Content: "Context window exceeded. Compressing history and retrying...",
-					})
-				}
-
-				al.forceCompression(agent, opts.SessionKey)
-				newHistory := agent.Sessions.GetHistory(opts.SessionKey)
-				newSummary := agent.Sessions.GetSummary(opts.SessionKey)
-				messages = agent.ContextBuilder.BuildMessages(
-					newHistory, newSummary, "",
-					nil, opts.Channel, opts.ChatID,
-				)
-				continue
-			}
-			break
-		}
-
-		if err != nil {
-			logger.ErrorCF("agent", "LLM call failed",
-				map[string]any{
-					"agent_id":  agent.ID,
-					"iteration": iteration,
-					"error":     err.Error(),
-				})
-			return "", iteration, fmt.Errorf("LLM call failed after retries: %w", err)
-		}
-+		response, err := al.executeLLMWithRetry(
-+			ctx, agent, opts, &messages,
-+			providerToolDefs, activeCandidates,
-+			activeModel, iteration,
-+		)
-+		if err != nil {
-+			return "", iteration, err
-+		}
-
-		go al.handleReasoning(
--- a/patch_readme.patch
+++ b/patch_readme.patch
@ -1,18 +0,0 @@
--- AGENT_LOOP_IMPROVEMENTS.md
-+++ AGENT_LOOP_IMPROVEMENTS.md
-@@ -4,14 +4,14 @@
-
- ## Phase 1: Architecture & Maintainability (Refactoring)
-- [ ] **Extract LLM Call & Retry Logic:** Refactor `runLLMIteration` by moving the LLM calling, fallback chain, and context window retry logic into a dedicated method (e.g., `executeLLMWithRetry`).
-- [ ] **Extract Tool Execution Logic:** Refactor `runLLMIteration` by moving the parallel tool execution (`sync.WaitGroup`), channel routing, and async callbacks into a dedicated method (e.g., `executeToolBatch`).
-- [ ] **State Machine / Explicit Flow:** Clean up the main loop logic to reduce nested `if/for` blocks and make the transition between generating, executing tools, and compressing context more explicit.
-+- [x] **Extract LLM Call & Retry Logic:** Refactor `runLLMIteration` by moving the LLM calling, fallback chain, and context window retry logic into a dedicated method (e.g., `executeLLMWithRetry`).
-+- [x] **Extract Tool Execution Logic:** Refactor `runLLMIteration` by moving the parallel tool execution (`sync.WaitGroup`), channel routing, and async callbacks into a dedicated method (e.g., `executeToolBatch`).
-+- [x] **State Machine / Explicit Flow:** Clean up the main loop logic to reduce nested `if/for` blocks and make the transition between generating, executing tools, and compressing context more explicit.
-
- ## Phase 2: Reliability & Error Handling
-- [ ] **Graceful Recovery on Tool Panic:** Add `defer recover()` inside the parallel tool execution goroutines to prevent a panicked tool from crashing the entire `AgentLoop`. Return the panic as an error string to the LLM.
-- [ ] **Exponential Backoff:** Replace the linear backoff in LLM retries (`time.Duration(retry+1) * 5 * time.Second`) with exponential backoff and jitter to better handle rate limits.
-+- [x] **Graceful Recovery on Tool Panic:** Add `defer recover()` inside the parallel tool execution goroutines to prevent a panicked tool from crashing the entire `AgentLoop`. Return the panic as an error string to the LLM.
-+- [x] **Exponential Backoff:** Replace the linear backoff in LLM retries (`time.Duration(retry+1) * 5 * time.Second`) with exponential backoff and jitter to better handle rate limits.
- - [ ] **Granular Error Classification:** Update `LLMProvider` interfaces to return structured, typed errors (e.g., `providers.ErrContextLengthExceeded`) instead of relying on fragile string matching.
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
--- a/pkg/agent/loop_audio.go
+++ b/pkg/agent/loop_audio.go
@ -0,0 +1,114 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"regexp"
+	"strings"
+
+	"jane/pkg/bus"
+	"jane/pkg/logger"
+	"jane/pkg/utils"
+)
+
+var audioAnnotationRe = regexp.MustCompile(`\[(voice|audio)(?::[^\]]*)?\]`)
+
+// transcribeAudioInMessage resolves audio media refs, transcribes them, and
+// replaces audio annotations in msg.Content with the transcribed text.
+// Returns the (possibly modified) message and true if audio was transcribed.
+func (al *AgentLoop) transcribeAudioInMessage(ctx context.Context, msg bus.InboundMessage) (bus.InboundMessage, bool) {
+	if al.transcriber == nil || al.mediaStore == nil || len(msg.Media) == 0 {
+		return msg, false
+	}
+
+	// Transcribe each audio media ref in order.
+	var transcriptions []string
+	for _, ref := range msg.Media {
+		path, meta, err := al.mediaStore.ResolveWithMeta(ref)
+		if err != nil {
+			logger.WarnCF("voice", "Failed to resolve media ref", map[string]any{"ref": ref, "error": err})
+			continue
+		}
+		if !utils.IsAudioFile(meta.Filename, meta.ContentType) {
+			continue
+		}
+		result, err := al.transcriber.Transcribe(ctx, path)
+		if err != nil {
+			logger.WarnCF("voice", "Transcription failed", map[string]any{"ref": ref, "error": err})
+			transcriptions = append(transcriptions, "")
+			continue
+		}
+		transcriptions = append(transcriptions, result.Text)
+	}
+
+	if len(transcriptions) == 0 {
+		return msg, false
+	}
+
+	al.sendTranscriptionFeedback(ctx, msg.Channel, msg.ChatID, msg.MessageID, transcriptions)
+
+	// Replace audio annotations sequentially with transcriptions.
+	idx := 0
+	newContent := audioAnnotationRe.ReplaceAllStringFunc(msg.Content, func(match string) string {
+		if idx >= len(transcriptions) {
+			return match
+		}
+		text := transcriptions[idx]
+		idx++
+		return "[voice: " + text + "]"
+	})
+
+	// Append any remaining transcriptions not matched by an annotation.
+	for ; idx < len(transcriptions); idx++ {
+		newContent += "\n[voice: " + transcriptions[idx] + "]"
+	}
+
+	msg.Content = newContent
+	return msg, true
+}
+
+// sendTranscriptionFeedback sends feedback to the user with the result of
+// audio transcription if the option is enabled. It uses Manager.SendMessage
+// which executes synchronously (rate limiting, splitting, retry) so that
+// ordering with the subsequent placeholder is guaranteed.
+func (al *AgentLoop) sendTranscriptionFeedback(
+	ctx context.Context,
+	channel, chatID, messageID string,
+	validTexts []string,
+) {
+	if !al.cfg.Voice.EchoTranscription {
+		return
+	}
+	if al.channelManager == nil {
+		return
+	}
+
+	var nonEmpty []string
+	for _, t := range validTexts {
+		if t != "" {
+			nonEmpty = append(nonEmpty, t)
+		}
+	}
+
+	var feedbackMsg string
+	if len(nonEmpty) > 0 {
+		feedbackMsg = "Transcript: " + strings.Join(nonEmpty, "\n")
+	} else {
+		feedbackMsg = "No voice detected in the audio"
+	}
+
+	err := al.channelManager.SendMessage(ctx, bus.OutboundMessage{
+		Channel:          channel,
+		ChatID:           chatID,
+		Content:          feedbackMsg,
+		ReplyToMessageID: messageID,
+	})
+	if err != nil {
+		logger.WarnCF("voice", "Failed to send transcription feedback", map[string]any{"error": err.Error()})
+	}
+}
--- a/pkg/agent/loop_command.go
+++ b/pkg/agent/loop_command.go
@ -0,0 +1,114 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"fmt"
+
+	"jane/pkg/bus"
+	"jane/pkg/commands"
+	"jane/pkg/providers"
+)
+
+func (al *AgentLoop) handleCommand(
+	ctx context.Context,
+	msg bus.InboundMessage,
+	agent *AgentInstance,
+	opts *processOptions,
+) (string, bool) {
+	if !commands.HasCommandPrefix(msg.Content) {
+		return "", false
+	}
+
+	if al.cmdRegistry == nil {
+		return "", false
+	}
+
+	rt := al.buildCommandsRuntime(agent, opts)
+	executor := commands.NewExecutor(al.cmdRegistry, rt)
+
+	var commandReply string
+	result := executor.Execute(ctx, commands.Request{
+		Channel:  msg.Channel,
+		ChatID:   msg.ChatID,
+		SenderID: msg.SenderID,
+		Text:     msg.Content,
+		Reply: func(text string) error {
+			commandReply = text
+			return nil
+		},
+	})
+
+	switch result.Outcome {
+	case commands.OutcomeHandled:
+		if result.Err != nil {
+			return mapCommandError(result), true
+		}
+		if commandReply != "" {
+			return commandReply, true
+		}
+		return "", true
+	default: // OutcomePassthrough — let the message fall through to LLM
+		return "", false
+	}
+}
+
+func (al *AgentLoop) buildCommandsRuntime(agent *AgentInstance, opts *processOptions) *commands.Runtime {
+	rt := &commands.Runtime{
+		Config:          al.cfg,
+		ListAgentIDs:    al.registry.ListAgentIDs,
+		ListDefinitions: al.cmdRegistry.Definitions,
+		GetEnabledChannels: func() []string {
+			if al.channelManager == nil {
+				return nil
+			}
+			return al.channelManager.GetEnabledChannels()
+		},
+		SwitchChannel: func(value string) error {
+			if al.channelManager == nil {
+				return fmt.Errorf("channel manager not initialized")
+			}
+			if _, exists := al.channelManager.GetChannel(value); !exists && value != "cli" {
+				return fmt.Errorf("channel '%s' not found or not enabled", value)
+			}
+			return nil
+		},
+	}
+	if agent != nil {
+		rt.GetModelInfo = func() (string, string) {
+			return agent.Model, al.cfg.Agents.Defaults.Provider
+		}
+		rt.SwitchModel = func(value string) (string, error) {
+			oldModel := agent.Model
+			agent.Model = value
+			return oldModel, nil
+		}
+
+		rt.ClearHistory = func() error {
+			if opts == nil {
+				return fmt.Errorf("process options not available")
+			}
+			if agent.Sessions == nil {
+				return fmt.Errorf("sessions not initialized for agent")
+			}
+
+			agent.Sessions.SetHistory(opts.SessionKey, make([]providers.Message, 0))
+			agent.Sessions.SetSummary(opts.SessionKey, "")
+			agent.Sessions.Save(opts.SessionKey)
+			return nil
+		}
+	}
+	return rt
+}
+
+func mapCommandError(result commands.ExecuteResult) string {
+	if result.Command == "" {
+		return fmt.Sprintf("Failed to execute command: %v", result.Err)
+	}
+	return fmt.Sprintf("Failed to execute /%s: %v", result.Command, result.Err)
+}
--- a/pkg/agent/loop_init.go
+++ b/pkg/agent/loop_init.go
@ -0,0 +1,362 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"jane/pkg/bus"
+	"jane/pkg/channels"
+	"jane/pkg/commands"
+	"jane/pkg/config"
+	"jane/pkg/logger"
+	"jane/pkg/media"
+	"jane/pkg/providers"
+	"jane/pkg/skills"
+	"jane/pkg/state"
+	"jane/pkg/tools"
+	"jane/pkg/voice"
+)
+
+func NewAgentLoop(
+	cfg *config.Config,
+	msgBus *bus.MessageBus,
+	provider providers.LLMProvider,
+) *AgentLoop {
+	registry := NewAgentRegistry(cfg, provider)
+
+	// Register shared tools to all agents
+	registerSharedTools(cfg, msgBus, registry, provider)
+
+	// Set up shared fallback chain
+	cooldown := providers.NewCooldownTracker()
+	fallbackChain := providers.NewFallbackChain(cooldown)
+
+	// Create state manager using default agent's workspace for channel recording
+	defaultAgent := registry.GetDefaultAgent()
+	var stateManager *state.Manager
+	if defaultAgent != nil {
+		stateManager = state.NewManager(defaultAgent.Workspace)
+	}
+
+	al := &AgentLoop{
+		bus:         msgBus,
+		cfg:         cfg,
+		registry:    registry,
+		state:       stateManager,
+		summarizing: sync.Map{},
+		fallback:    fallbackChain,
+		cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()),
+	}
+
+	return al
+}
+
+// registerSharedTools registers tools that are shared across all agents (web, message, spawn).
+func registerSharedTools(
+	cfg *config.Config,
+	msgBus *bus.MessageBus,
+	registry *AgentRegistry,
+	provider providers.LLMProvider,
+) {
+	for _, agentID := range registry.ListAgentIDs() {
+		agent, ok := registry.GetAgent(agentID)
+		if !ok {
+			continue
+		}
+
+		if cfg.Tools.IsToolEnabled("web") {
+			searchTool, err := tools.NewWebSearchTool(tools.WebSearchToolOptions{
+				BraveAPIKeys:         config.MergeAPIKeys(cfg.Tools.Web.Brave.APIKey, cfg.Tools.Web.Brave.APIKeys),
+				BraveMaxResults:      cfg.Tools.Web.Brave.MaxResults,
+				BraveEnabled:         cfg.Tools.Web.Brave.Enabled,
+				TavilyAPIKeys:        config.MergeAPIKeys(cfg.Tools.Web.Tavily.APIKey, cfg.Tools.Web.Tavily.APIKeys),
+				TavilyBaseURL:        cfg.Tools.Web.Tavily.BaseURL,
+				TavilyMaxResults:     cfg.Tools.Web.Tavily.MaxResults,
+				TavilyEnabled:        cfg.Tools.Web.Tavily.Enabled,
+				DuckDuckGoMaxResults: cfg.Tools.Web.DuckDuckGo.MaxResults,
+				DuckDuckGoEnabled:    cfg.Tools.Web.DuckDuckGo.Enabled,
+				PerplexityAPIKeys: config.MergeAPIKeys(
+					cfg.Tools.Web.Perplexity.APIKey,
+					cfg.Tools.Web.Perplexity.APIKeys,
+				),
+				PerplexityMaxResults: cfg.Tools.Web.Perplexity.MaxResults,
+				PerplexityEnabled:    cfg.Tools.Web.Perplexity.Enabled,
+				SearXNGBaseURL:       cfg.Tools.Web.SearXNG.BaseURL,
+				SearXNGMaxResults:    cfg.Tools.Web.SearXNG.MaxResults,
+				SearXNGEnabled:       cfg.Tools.Web.SearXNG.Enabled,
+				GLMSearchAPIKey:      cfg.Tools.Web.GLMSearch.APIKey,
+				GLMSearchBaseURL:     cfg.Tools.Web.GLMSearch.BaseURL,
+				GLMSearchEngine:      cfg.Tools.Web.GLMSearch.SearchEngine,
+				GLMSearchMaxResults:  cfg.Tools.Web.GLMSearch.MaxResults,
+				GLMSearchEnabled:     cfg.Tools.Web.GLMSearch.Enabled,
+				Proxy:                cfg.Tools.Web.Proxy,
+			})
+			if err != nil {
+				logger.ErrorCF("agent", "Failed to create web search tool", map[string]any{"error": err.Error()})
+			} else if searchTool != nil {
+				agent.Tools.Register(searchTool)
+			}
+		}
+		if cfg.Tools.IsToolEnabled("web_fetch") {
+			fetchTool, err := tools.NewWebFetchToolWithProxy(50000, cfg.Tools.Web.Proxy, cfg.Tools.Web.FetchLimitBytes)
+			if err != nil {
+				logger.ErrorCF("agent", "Failed to create web fetch tool", map[string]any{"error": err.Error()})
+			} else {
+				agent.Tools.Register(fetchTool)
+			}
+		}
+
+		// Hardware tools (I2C, SPI) - Linux only, returns error on other platforms
+		if cfg.Tools.IsToolEnabled("i2c") {
+			agent.Tools.Register(tools.NewI2CTool())
+		}
+		if cfg.Tools.IsToolEnabled("spi") {
+			agent.Tools.Register(tools.NewSPITool())
+		}
+
+		// Message tool
+		if cfg.Tools.IsToolEnabled("message") {
+			messageTool := tools.NewMessageTool()
+			messageTool.SetSendCallback(func(channel, chatID, content string) error {
+				pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+				defer pubCancel()
+				return msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
+					Channel: channel,
+					ChatID:  chatID,
+					Content: content,
+				})
+			})
+			agent.Tools.Register(messageTool)
+		}
+
+		// Send file tool (outbound media via MediaStore — store injected later by SetMediaStore)
+		if cfg.Tools.IsToolEnabled("send_file") {
+			sendFileTool := tools.NewSendFileTool(
+				agent.Workspace,
+				cfg.Agents.Defaults.RestrictToWorkspace,
+				cfg.Agents.Defaults.GetMaxMediaSize(),
+				nil,
+			)
+			agent.Tools.Register(sendFileTool)
+		}
+
+		// Skill discovery and installation tools
+		skills_enabled := cfg.Tools.IsToolEnabled("skills")
+		find_skills_enable := cfg.Tools.IsToolEnabled("find_skills")
+		install_skills_enable := cfg.Tools.IsToolEnabled("install_skill")
+		if skills_enabled && (find_skills_enable || install_skills_enable) {
+			registryMgr := skills.NewRegistryManagerFromConfig(skills.RegistryConfig{
+				MaxConcurrentSearches: cfg.Tools.Skills.MaxConcurrentSearches,
+				ClawHub:               skills.ClawHubConfig(cfg.Tools.Skills.Registries.ClawHub),
+			})
+
+			if find_skills_enable {
+				searchCache := skills.NewSearchCache(
+					cfg.Tools.Skills.SearchCache.MaxSize,
+					time.Duration(cfg.Tools.Skills.SearchCache.TTLSeconds)*time.Second,
+				)
+				agent.Tools.Register(tools.NewFindSkillsTool(registryMgr, searchCache))
+			}
+
+			if install_skills_enable {
+				agent.Tools.Register(tools.NewInstallSkillTool(registryMgr, agent.Workspace))
+			}
+		}
+
+		// Spawn tool with allowlist checker
+		if cfg.Tools.IsToolEnabled("spawn") {
+			if cfg.Tools.IsToolEnabled("subagent") {
+				subagentManager := tools.NewSubagentManager(provider, agent.Model, agent.Workspace)
+				subagentManager.SetLLMOptions(agent.MaxTokens, agent.Temperature)
+				spawnTool := tools.NewSpawnTool(subagentManager)
+				currentAgentID := agentID
+				spawnTool.SetAllowlistChecker(func(targetAgentID string) bool {
+					return registry.CanSpawnSubagent(currentAgentID, targetAgentID)
+				})
+				agent.Tools.Register(spawnTool)
+			} else {
+				logger.WarnCF("agent", "spawn tool requires subagent to be enabled", nil)
+			}
+		}
+	}
+}
+
+func (al *AgentLoop) Run(ctx context.Context) error {
+	al.running.Store(true)
+	if err := al.ensureMCPInitialized(ctx); err != nil {
+		return err
+	}
+
+	for al.running.Load() {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			msg, ok := al.bus.ConsumeInbound(ctx)
+			if !ok {
+				continue
+			}
+
+			// Process message
+			func() {
+				// TODO: Re-enable media cleanup after inbound media is properly consumed by the agent.
+				// Currently disabled because files are deleted before the LLM can access their content.
+				// defer func() {
+				// 	if al.mediaStore != nil && msg.MediaScope != "" {
+				// 		if releaseErr := al.mediaStore.ReleaseAll(msg.MediaScope); releaseErr != nil {
+				// 			logger.WarnCF("agent", "Failed to release media", map[string]any{
+				// 				"scope": msg.MediaScope,
+				// 				"error": releaseErr.Error(),
+				// 			})
+				// 		}
+				// 	}
+				// }()
+
+				response, err := al.processMessage(ctx, msg)
+				if err != nil {
+					response = fmt.Sprintf("Error processing message: %v", err)
+				}
+
+				if response != "" {
+					// Check if the message tool already sent a response during this round.
+					// If so, skip publishing to avoid duplicate messages to the user.
+					// Use default agent's tools to check (message tool is shared).
+					alreadySent := false
+					defaultAgent := al.registry.GetDefaultAgent()
+					if defaultAgent != nil {
+						if tool, ok := defaultAgent.Tools.Get("message"); ok {
+							if mt, ok := tool.(*tools.MessageTool); ok {
+								alreadySent = mt.HasSentInRound()
+							}
+						}
+					}
+
+					if !alreadySent {
+						al.bus.PublishOutbound(ctx, bus.OutboundMessage{
+							Channel: msg.Channel,
+							ChatID:  msg.ChatID,
+							Content: response,
+						})
+						logger.InfoCF("agent", "Published outbound response",
+							map[string]any{
+								"channel":     msg.Channel,
+								"chat_id":     msg.ChatID,
+								"content_len": len(response),
+							})
+					} else {
+						logger.DebugCF(
+							"agent",
+							"Skipped outbound (message tool already sent)",
+							map[string]any{"channel": msg.Channel},
+						)
+					}
+				}
+			}()
+		}
+	}
+
+	return nil
+}
+
+func (al *AgentLoop) Stop() {
+	al.running.Store(false)
+}
+
+// Close releases resources held by agent session stores. Call after Stop.
+func (al *AgentLoop) Close() {
+	mcpManager := al.mcp.takeManager()
+
+	if mcpManager != nil {
+		if err := mcpManager.Close(); err != nil {
+			logger.ErrorCF("agent", "Failed to close MCP manager",
+				map[string]any{
+					"error": err.Error(),
+				})
+		}
+	}
+
+	al.registry.Close()
+}
+
+func (al *AgentLoop) RegisterTool(tool tools.Tool) {
+	for _, agentID := range al.registry.ListAgentIDs() {
+		if agent, ok := al.registry.GetAgent(agentID); ok {
+			agent.Tools.Register(tool)
+		}
+	}
+}
+
+func (al *AgentLoop) SetChannelManager(cm *channels.Manager) {
+	al.channelManager = cm
+}
+
+// SetMediaStore injects a MediaStore for media lifecycle management.
+func (al *AgentLoop) SetMediaStore(s media.MediaStore) {
+	al.mediaStore = s
+
+	// Propagate store to send_file tools in all agents.
+	al.registry.ForEachTool("send_file", func(t tools.Tool) {
+		if sf, ok := t.(*tools.SendFileTool); ok {
+			sf.SetMediaStore(s)
+		}
+	})
+}
+
+// SetTranscriber injects a voice transcriber for agent-level audio transcription.
+func (al *AgentLoop) SetTranscriber(t voice.Transcriber) {
+	al.transcriber = t
+}
+
+// RecordLastChannel records the last active channel for this workspace.
+// This uses the atomic state save mechanism to prevent data loss on crash.
+func (al *AgentLoop) RecordLastChannel(channel string) error {
+	if al.state == nil {
+		return nil
+	}
+	return al.state.SetLastChannel(channel)
+}
+
+// RecordLastChatID records the last active chat ID for this workspace.
+// This uses the atomic state save mechanism to prevent data loss on crash.
+func (al *AgentLoop) RecordLastChatID(chatID string) error {
+	if al.state == nil {
+		return nil
+	}
+	return al.state.SetLastChatID(chatID)
+}
+
+// GetStartupInfo returns information about loaded tools and skills for logging.
+func (al *AgentLoop) GetStartupInfo() map[string]any {
+	info := make(map[string]any)
+
+	agent := al.registry.GetDefaultAgent()
+	if agent == nil {
+		return info
+	}
+
+	// Tools info
+	toolsList := agent.Tools.List()
+	info["tools"] = map[string]any{
+		"count": len(toolsList),
+		"names": toolsList,
+	}
+
+	// Skills info
+	info["skills"] = agent.ContextBuilder.GetSkillsInfo()
+
+	// Agents info
+	info["agents"] = map[string]any{
+		"count": len(al.registry.ListAgentIDs()),
+		"ids":   al.registry.ListAgentIDs(),
+	}
+
+	return info
+}
--- a/pkg/agent/loop_llm.go
+++ b/pkg/agent/loop_llm.go
@ -0,0 +1,417 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"jane/pkg/bus"
+	"jane/pkg/constants"
+	"jane/pkg/logger"
+	"jane/pkg/providers"
+	"jane/pkg/utils"
+)
+
+// runAgentLoop is the core message processing logic.
+func (al *AgentLoop) runAgentLoop(
+	ctx context.Context,
+	agent *AgentInstance,
+	opts processOptions,
+) (string, error) {
+	// 0. Record last channel for heartbeat notifications (skip internal channels and cli)
+	if opts.Channel != "" && opts.ChatID != "" {
+		if !constants.IsInternalChannel(opts.Channel) {
+			channelKey := fmt.Sprintf("%s:%s", opts.Channel, opts.ChatID)
+			if err := al.RecordLastChannel(channelKey); err != nil {
+				logger.WarnCF(
+					"agent",
+					"Failed to record last channel",
+					map[string]any{"error": err.Error()},
+				)
+			}
+		}
+	}
+
+	// 1. Build messages (skip history for heartbeat)
+	var history []providers.Message
+	var summary string
+	if !opts.NoHistory {
+		history = agent.Sessions.GetHistory(opts.SessionKey)
+		summary = agent.Sessions.GetSummary(opts.SessionKey)
+	}
+	messages := agent.ContextBuilder.BuildMessages(
+		history,
+		summary,
+		opts.UserMessage,
+		opts.Media,
+		opts.Channel,
+		opts.ChatID,
+	)
+
+	// Resolve media:// refs to base64 data URLs (streaming)
+	maxMediaSize := al.cfg.Agents.Defaults.GetMaxMediaSize()
+	messages = resolveMediaRefs(messages, al.mediaStore, maxMediaSize)
+
+	// 2. Save user message to session
+	agent.Sessions.AddMessage(opts.SessionKey, "user", opts.UserMessage)
+
+	// 3. Run LLM iteration loop
+	finalContent, iteration, err := al.runLLMIteration(ctx, agent, messages, opts)
+	if err != nil {
+		return "", err
+	}
+
+	// If last tool had ForUser content and we already sent it, we might not need to send final response
+	// This is controlled by the tool's Silent flag and ForUser content
+
+	// 4. Handle empty response
+	if finalContent == "" {
+		finalContent = opts.DefaultResponse
+	}
+
+	// 5. Save final assistant message to session
+	agent.Sessions.AddMessage(opts.SessionKey, "assistant", finalContent)
+	agent.Sessions.Save(opts.SessionKey)
+
+	// 6. Optional: summarization
+	if opts.EnableSummary {
+		al.maybeSummarize(agent, opts.SessionKey, opts.Channel, opts.ChatID)
+	}
+
+	// 7. Optional: send response via bus
+	if opts.SendResponse {
+		al.bus.PublishOutbound(ctx, bus.OutboundMessage{
+			Channel: opts.Channel,
+			ChatID:  opts.ChatID,
+			Content: finalContent,
+		})
+	}
+
+	// 8. Log response
+	responsePreview := utils.Truncate(finalContent, 120)
+	logger.InfoCF("agent", fmt.Sprintf("Response: %s", responsePreview),
+		map[string]any{
+			"agent_id":     agent.ID,
+			"session_key":  opts.SessionKey,
+			"iterations":   iteration,
+			"final_length": len(finalContent),
+		})
+
+	return finalContent, nil
+}
+
+func (al *AgentLoop) targetReasoningChannelID(channelName string) (chatID string) {
+	if al.channelManager == nil {
+		return ""
+	}
+	if ch, ok := al.channelManager.GetChannel(channelName); ok {
+		return ch.ReasoningChannelID()
+	}
+	return ""
+}
+
+func (al *AgentLoop) handleReasoning(
+	ctx context.Context,
+	reasoningContent, channelName, channelID string,
+) {
+	if reasoningContent == "" || channelName == "" || channelID == "" {
+		return
+	}
+
+	// Check context cancellation before attempting to publish,
+	// since PublishOutbound's select may race between send and ctx.Done().
+	if ctx.Err() != nil {
+		return
+	}
+
+	// Use a short timeout so the goroutine does not block indefinitely when
+	// the outbound bus is full.  Reasoning output is best-effort; dropping it
+	// is acceptable to avoid goroutine accumulation.
+	pubCtx, pubCancel := context.WithTimeout(ctx, 5*time.Second)
+	defer pubCancel()
+
+	if err := al.bus.PublishOutbound(pubCtx, bus.OutboundMessage{
+		Channel: channelName,
+		ChatID:  channelID,
+		Content: reasoningContent,
+	}); err != nil {
+		// Treat context.DeadlineExceeded / context.Canceled as expected
+		// (bus full under load, or parent canceled).  Check the error
+		// itself rather than ctx.Err(), because pubCtx may time out
+		// (5 s) while the parent ctx is still active.
+		// Also treat ErrBusClosed as expected — it occurs during normal
+		// shutdown when the bus is closed before all goroutines finish.
+		if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) ||
+			errors.Is(err, bus.ErrBusClosed) {
+			logger.DebugCF("agent", "Reasoning publish skipped (timeout/cancel)", map[string]any{
+				"channel": channelName,
+				"error":   err.Error(),
+			})
+		} else {
+			logger.WarnCF("agent", "Failed to publish reasoning (best-effort)", map[string]any{
+				"channel": channelName,
+				"error":   err.Error(),
+			})
+		}
+	}
+}
+
+// runLLMIteration executes the LLM call loop with tool handling.
+func (al *AgentLoop) runLLMIteration(
+	ctx context.Context,
+	agent *AgentInstance,
+	messages []providers.Message,
+	opts processOptions,
+) (string, int, error) {
+	iteration := 0
+	var finalContent string
+
+	// Determine effective model tier for this conversation turn.
+	// selectCandidates evaluates routing once and the decision is sticky for
+	// all tool-follow-up iterations within the same turn so that a multi-step
+	// tool chain doesn't switch models mid-way through.
+	activeCandidates, activeModel := al.selectCandidates(agent, opts.UserMessage, messages)
+
+	for iteration < agent.MaxIterations {
+		iteration++
+
+		logger.DebugCF("agent", "LLM iteration",
+			map[string]any{
+				"agent_id":  agent.ID,
+				"iteration": iteration,
+				"max":       agent.MaxIterations,
+			})
+
+		// Build tool definitions
+		providerToolDefs := agent.Tools.ToProviderDefs()
+
+		// Log LLM request details
+		logger.DebugCF("agent", "LLM request",
+			map[string]any{
+				"agent_id":          agent.ID,
+				"iteration":         iteration,
+				"model":             activeModel,
+				"messages_count":    len(messages),
+				"tools_count":       len(providerToolDefs),
+				"max_tokens":        agent.MaxTokens,
+				"temperature":       agent.Temperature,
+				"system_prompt_len": len(messages[0].Content),
+			})
+
+		// Log full messages (detailed)
+		logger.DebugCF("agent", "Full LLM request",
+			map[string]any{
+				"iteration":     iteration,
+				"messages_json": formatMessagesForLog(messages),
+				"tools_json":    formatToolsForLog(providerToolDefs),
+			})
+
+		// Call LLM with fallback chain and retry logic
+		response, err := al.executeLLMWithRetry(
+			ctx, agent, opts, &messages,
+			providerToolDefs, activeCandidates,
+			activeModel, iteration,
+		)
+		if err != nil {
+			return "", iteration, err
+		}
+		go al.handleReasoning(
+			ctx,
+			response.Reasoning,
+			opts.Channel,
+			al.targetReasoningChannelID(opts.Channel),
+		)
+
+		logger.DebugCF("agent", "LLM response",
+			map[string]any{
+				"agent_id":       agent.ID,
+				"iteration":      iteration,
+				"content_chars":  len(response.Content),
+				"tool_calls":     len(response.ToolCalls),
+				"reasoning":      response.Reasoning,
+				"target_channel": al.targetReasoningChannelID(opts.Channel),
+				"channel":        opts.Channel,
+			})
+		// Check if no tool calls - then check reasoning content if any
+		if len(response.ToolCalls) == 0 {
+			finalContent = response.Content
+			if finalContent == "" && response.ReasoningContent != "" {
+				finalContent = response.ReasoningContent
+			}
+			logger.InfoCF("agent", "LLM response without tool calls (direct answer)",
+				map[string]any{
+					"agent_id":      agent.ID,
+					"iteration":     iteration,
+					"content_chars": len(finalContent),
+				})
+			break
+		}
+
+		normalizedToolCalls := make([]providers.ToolCall, 0, len(response.ToolCalls))
+		for _, tc := range response.ToolCalls {
+			normalizedToolCalls = append(normalizedToolCalls, providers.NormalizeToolCall(tc))
+		}
+
+		// Log tool calls
+		toolNames := make([]string, 0, len(normalizedToolCalls))
+		for _, tc := range normalizedToolCalls {
+			toolNames = append(toolNames, tc.Name)
+		}
+		logger.InfoCF("agent", "LLM requested tool calls",
+			map[string]any{
+				"agent_id":  agent.ID,
+				"tools":     toolNames,
+				"count":     len(normalizedToolCalls),
+				"iteration": iteration,
+			})
+
+		// Build assistant message with tool calls
+		assistantMsg := providers.Message{
+			Role:             "assistant",
+			Content:          response.Content,
+			ReasoningContent: response.ReasoningContent,
+		}
+		for _, tc := range normalizedToolCalls {
+			argumentsJSON, _ := json.Marshal(tc.Arguments)
+			// Copy ExtraContent to ensure thought_signature is persisted for Gemini 3
+			extraContent := tc.ExtraContent
+			thoughtSignature := ""
+			if tc.Function != nil {
+				thoughtSignature = tc.Function.ThoughtSignature
+			}
+
+			assistantMsg.ToolCalls = append(assistantMsg.ToolCalls, providers.ToolCall{
+				ID:   tc.ID,
+				Type: "function",
+				Name: tc.Name,
+				Function: &providers.FunctionCall{
+					Name:             tc.Name,
+					Arguments:        string(argumentsJSON),
+					ThoughtSignature: thoughtSignature,
+				},
+				ExtraContent:     extraContent,
+				ThoughtSignature: thoughtSignature,
+			})
+		}
+		messages = append(messages, assistantMsg)
+
+		// Save assistant message with tool calls to session
+		agent.Sessions.AddFullMessage(opts.SessionKey, assistantMsg)
+
+		// Execute tool calls in parallel
+		agentResults := al.executeToolBatch(ctx, agent, opts, normalizedToolCalls, iteration)
+
+		// Process results in original order (send to user, save to session)
+		for _, r := range agentResults {
+			// Send ForUser content to user immediately if not Silent
+			if !r.result.Silent && r.result.ForUser != "" && opts.SendResponse {
+				al.bus.PublishOutbound(ctx, bus.OutboundMessage{
+					Channel: opts.Channel,
+					ChatID:  opts.ChatID,
+					Content: r.result.ForUser,
+				})
+				logger.DebugCF("agent", "Sent tool result to user",
+					map[string]any{
+						"tool":        r.tc.Name,
+						"content_len": len(r.result.ForUser),
+					})
+			}
+
+			// If tool returned media refs, publish them as outbound media
+			if len(r.result.Media) > 0 {
+				parts := make([]bus.MediaPart, 0, len(r.result.Media))
+				for _, ref := range r.result.Media {
+					part := bus.MediaPart{Ref: ref}
+					if al.mediaStore != nil {
+						if _, meta, err := al.mediaStore.ResolveWithMeta(ref); err == nil {
+							part.Filename = meta.Filename
+							part.ContentType = meta.ContentType
+							part.Type = inferMediaType(meta.Filename, meta.ContentType)
+						}
+					}
+					parts = append(parts, part)
+				}
+				al.bus.PublishOutboundMedia(ctx, bus.OutboundMediaMessage{
+					Channel: opts.Channel,
+					ChatID:  opts.ChatID,
+					Parts:   parts,
+				})
+			}
+
+			// Determine content for LLM based on tool result
+			contentForLLM := r.result.ForLLM
+			if contentForLLM == "" && r.result.Err != nil {
+				contentForLLM = r.result.Err.Error()
+			}
+
+			toolResultMsg := providers.Message{
+				Role:       "tool",
+				Content:    contentForLLM,
+				ToolCallID: r.tc.ID,
+			}
+			messages = append(messages, toolResultMsg)
+
+			// Save tool result message to session
+			agent.Sessions.AddFullMessage(opts.SessionKey, toolResultMsg)
+		}
+
+		// Tick down TTL of discovered tools after processing tool results.
+		// Only reached when tool calls were made (the loop continues);
+		// the break on no-tool-call responses skips this.
+		// NOTE: This is safe because processMessage is sequential per agent.
+		// If per-agent concurrency is added, TTL consistency between
+		// ToProviderDefs and Get must be re-evaluated.
+		agent.Tools.TickTTL()
+		logger.DebugCF("agent", "TTL tick after tool execution", map[string]any{
+			"agent_id": agent.ID, "iteration": iteration,
+		})
+	}
+
+	return finalContent, iteration, nil
+}
+
+// selectCandidates returns the model candidates and resolved model name to use
+// for a conversation turn. When model routing is configured and the incoming
+// message scores below the complexity threshold, it returns the light model
+// candidates instead of the primary ones.
+//
+// The returned (candidates, model) pair is used for all LLM calls within one
+// turn — tool follow-up iterations use the same tier as the initial call so
+// that a multi-step tool chain doesn't switch models mid-way.
+func (al *AgentLoop) selectCandidates(
+	agent *AgentInstance,
+	userMsg string,
+	history []providers.Message,
+) (candidates []providers.FallbackCandidate, model string) {
+	if agent.Router == nil || len(agent.LightCandidates) == 0 {
+		return agent.Candidates, agent.Model
+	}
+
+	_, usedLight, score := agent.Router.SelectModel(userMsg, history, agent.Model)
+	if !usedLight {
+		logger.DebugCF("agent", "Model routing: primary model selected",
+			map[string]any{
+				"agent_id":  agent.ID,
+				"score":     score,
+				"threshold": agent.Router.Threshold(),
+			})
+		return agent.Candidates, agent.Model
+	}
+
+	logger.InfoCF("agent", "Model routing: light model selected",
+		map[string]any{
+			"agent_id":    agent.ID,
+			"light_model": agent.Router.LightModel(),
+			"score":       score,
+			"threshold":   agent.Router.Threshold(),
+		})
+	return agent.LightCandidates, agent.Router.LightModel()
+}
--- a/pkg/agent/loop_medical.go
+++ b/pkg/agent/loop_medical.go
@ -0,0 +1,153 @@
+package agent
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"jane/pkg/bus"
+	"jane/pkg/logger"
+)
+
+// The medical CoT state machine phases
+const (
+	PhaseExtraction          = "extraction"
+	PhaseTemporalCorrelation = "temporal_correlation"
+	PhaseTheoryGeneration    = "theory_generation"
+	PhaseVerification        = "verification"
+	PhaseSafetyDisclaimers   = "safety_disclaimers"
+)
+
+// processMedicalRequest implements the medical persona CoT loop
+func (al *AgentLoop) processMedicalRequest(
+	ctx context.Context,
+	agent *AgentInstance,
+	opts processOptions,
+) (string, error) {
+	logger.InfoCF("medical", "Starting clinical CoT loop", map[string]any{
+		"session_key": opts.SessionKey,
+	})
+
+	// Detect target patient from message
+	targetPatient := detectTargetPatient(opts.UserMessage)
+	if targetPatient == "" {
+		// If no specific patient is explicitly asked for, we ask the user for clarification.
+		msg := "Please specify the patient you are analyzing (e.g., 'Analyze patient John Doe')."
+		if opts.SendResponse {
+			al.bus.PublishOutbound(ctx, bus.OutboundMessage{
+				Channel: opts.Channel,
+				ChatID:  opts.ChatID,
+				Content: msg,
+			})
+		}
+		return msg, nil
+	}
+
+	// Ensure the session history is isolated to this specific patient and not globally
+	// shared across patients if the clinician uses the same chat session.
+	patientSessionKey := opts.SessionKey + ":patient:" + targetPatient
+
+	// Lock the workspace path to the patient directory
+	patientWorkspace := filepath.Join(agent.Workspace, targetPatient)
+
+	// We must not modify the shared agent instance directly to avoid data races.
+	// Instead, we clone the agent instance for this specific request.
+	clonedAgent := *agent
+	clonedAgent.Workspace = patientWorkspace
+
+	var finalResponse strings.Builder
+	finalResponse.WriteString(fmt.Sprintf("Clinician Agent initialized for patient: %s\n\n", targetPatient))
+
+	// CoT State Machine variables
+	var currentContext string = opts.UserMessage
+
+	phases := []string{
+		PhaseExtraction,
+		PhaseTemporalCorrelation,
+		PhaseTheoryGeneration,
+		PhaseVerification,
+		PhaseSafetyDisclaimers,
+	}
+
+	for _, phase := range phases {
+		logger.DebugCF("medical", "Executing phase", map[string]any{"phase": phase})
+
+		prompt := buildPhasePrompt(phase, currentContext)
+
+		// Create a temporary opts for this phase
+		phaseOpts := opts
+		phaseOpts.SessionKey = patientSessionKey
+		phaseOpts.UserMessage = prompt
+		phaseOpts.SendResponse = false // don't send intermediate steps to bus
+		phaseOpts.EnableSummary = false
+
+		// Run a standard single LLM execution for this phase
+		phaseResult, err := al.runAgentLoop(ctx, &clonedAgent, phaseOpts)
+		if err != nil {
+			logger.ErrorCF("medical", "Phase failed", map[string]any{
+				"phase": phase,
+				"error": err.Error(),
+			})
+			return "", err
+		}
+
+		// Accumulate result
+		finalResponse.WriteString(fmt.Sprintf("### [%s]\n%s\n\n", phase, phaseResult))
+
+		// Pass result as context to next phase
+		currentContext = currentContext + "\n\n" + fmt.Sprintf("Result of %s:\n%s", phase, phaseResult)
+
+		// Mandatory safety check abort
+		if phase == PhaseSafetyDisclaimers {
+			if strings.Contains(strings.ToLower(phaseResult), "life-threatening") ||
+				strings.Contains(strings.ToLower(phaseResult), "red flag") {
+				finalResponse.WriteString("\n⚠️ **RED FLAG DETECTED: This requires immediate emergency medical attention.**\n")
+			}
+		}
+	}
+
+	// Send to bus if requested
+	if opts.SendResponse {
+		al.bus.PublishOutbound(ctx, bus.OutboundMessage{
+			Channel: opts.Channel,
+			ChatID:  opts.ChatID,
+			Content: finalResponse.String(),
+		})
+	}
+
+	return finalResponse.String(), nil
+}
+
+func buildPhasePrompt(phase string, context string) string {
+	basePrompt := "You are The Clinician, an expert medical reasoning agent.\nContext:\n%s\n\nTask:\n"
+
+	switch phase {
+	case PhaseExtraction:
+		return fmt.Sprintf(basePrompt, context) + "Extract all clinical terminology, symptoms, and vital signs from the context."
+	case PhaseTemporalCorrelation:
+		return fmt.Sprintf(basePrompt, context) + "Analyze the temporal correlation of symptoms. Scan for recurring patterns in the patient's history."
+	case PhaseTheoryGeneration:
+		return fmt.Sprintf(basePrompt, context) + "Generate a ranked list of potential causes (DDx) and pathophysiological theories based on the extracted symptoms and patterns."
+	case PhaseVerification:
+		return fmt.Sprintf(basePrompt, context) + "Verify the proposed theories and any implicit remedies against the patient's Allergies and Medications profile."
+	case PhaseSafetyDisclaimers:
+		return fmt.Sprintf(basePrompt, context) + "Provide mandatory clinical disclaimers. Explicitly state whether any 'Life-Threatening' or 'Red Flag' symptoms were detected."
+	default:
+		return context
+	}
+}
+
+func detectTargetPatient(message string) string {
+	// Simple regex to extract patient name (e.g., "patient John Doe" or "patient: John Doe")
+	re := regexp.MustCompile(`(?i)patient\s*:?\s*([a-zA-Z0-9_]+(?:\s+[a-zA-Z0-9_]+)*)`)
+	matches := re.FindStringSubmatch(message)
+	if len(matches) > 1 {
+		// Clean up the patient name to make it directory-safe
+		patientName := strings.TrimSpace(matches[1])
+		patientName = strings.ReplaceAll(patientName, " ", "_")
+		return patientName
+	}
+	return ""
+}
--- a/pkg/agent/loop_process.go
+++ b/pkg/agent/loop_process.go
@ -0,0 +1,244 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"jane/pkg/bus"
+	"jane/pkg/constants"
+	"jane/pkg/logger"
+	"jane/pkg/routing"
+	"jane/pkg/utils"
+)
+
+func (al *AgentLoop) ProcessDirect(
+	ctx context.Context,
+	content, sessionKey string,
+) (string, error) {
+	return al.ProcessDirectWithChannel(ctx, content, sessionKey, "cli", "direct")
+}
+
+func (al *AgentLoop) ProcessDirectWithChannel(
+	ctx context.Context,
+	content, sessionKey, channel, chatID string,
+) (string, error) {
+	if err := al.ensureMCPInitialized(ctx); err != nil {
+		return "", err
+	}
+
+	msg := bus.InboundMessage{
+		Channel:    channel,
+		SenderID:   "cron",
+		ChatID:     chatID,
+		Content:    content,
+		SessionKey: sessionKey,
+	}
+
+	return al.processMessage(ctx, msg)
+}
+
+// ProcessHeartbeat processes a heartbeat request without session history.
+// Each heartbeat is independent and doesn't accumulate context.
+func (al *AgentLoop) ProcessHeartbeat(
+	ctx context.Context,
+	content, channel, chatID string,
+) (string, error) {
+	agent := al.registry.GetDefaultAgent()
+	if agent == nil {
+		return "", fmt.Errorf("no default agent for heartbeat")
+	}
+	return al.runAgentLoop(ctx, agent, processOptions{
+		SessionKey:      "heartbeat",
+		Channel:         channel,
+		ChatID:          chatID,
+		UserMessage:     content,
+		DefaultResponse: defaultResponse,
+		EnableSummary:   false,
+		SendResponse:    false,
+		NoHistory:       true, // Don't load session history for heartbeat
+	})
+}
+
+func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) (string, error) {
+	// Add message preview to log (show full content for error messages)
+	var logContent string
+	if strings.Contains(msg.Content, "Error:") || strings.Contains(msg.Content, "error") {
+		logContent = msg.Content // Full content for errors
+	} else {
+		logContent = utils.Truncate(msg.Content, 80)
+	}
+	logger.InfoCF(
+		"agent",
+		fmt.Sprintf("Processing message from %s:%s: %s", msg.Channel, msg.SenderID, logContent),
+		map[string]any{
+			"channel":     msg.Channel,
+			"chat_id":     msg.ChatID,
+			"sender_id":   msg.SenderID,
+			"session_key": msg.SessionKey,
+		},
+	)
+
+	var hadAudio bool
+	msg, hadAudio = al.transcribeAudioInMessage(ctx, msg)
+
+	// For audio messages the placeholder was deferred by the channel.
+	// Now that transcription (and optional feedback) is done, send it.
+	if hadAudio && al.channelManager != nil {
+		al.channelManager.SendPlaceholder(ctx, msg.Channel, msg.ChatID)
+	}
+
+	// Route system messages to processSystemMessage
+	if msg.Channel == "system" {
+		return al.processSystemMessage(ctx, msg)
+	}
+
+	route, agent, routeErr := al.resolveMessageRoute(msg)
+	if routeErr != nil {
+		return "", routeErr
+	}
+
+	// Reset message-tool state for this round so we don't skip publishing due to a previous round.
+	if tool, ok := agent.Tools.Get("message"); ok {
+		if resetter, ok := tool.(interface{ ResetSentInRound() }); ok {
+			resetter.ResetSentInRound()
+		}
+	}
+
+	// Resolve session key from route, while preserving explicit agent-scoped keys.
+	scopeKey := resolveScopeKey(route, msg.SessionKey)
+	sessionKey := scopeKey
+
+	logger.InfoCF("agent", "Routed message",
+		map[string]any{
+			"agent_id":      agent.ID,
+			"scope_key":     scopeKey,
+			"session_key":   sessionKey,
+			"matched_by":    route.MatchedBy,
+			"route_agent":   route.AgentID,
+			"route_channel": route.Channel,
+		})
+
+	opts := processOptions{
+		SessionKey:      sessionKey,
+		Channel:         msg.Channel,
+		ChatID:          msg.ChatID,
+		UserMessage:     msg.Content,
+		Media:           msg.Media,
+		DefaultResponse: defaultResponse,
+		EnableSummary:   true,
+		SendResponse:    false,
+	}
+
+	// Medical Persona specific routing interception
+	if agent != nil && agent.ID == "the-clinician" {
+		return al.processMedicalRequest(ctx, agent, opts)
+	}
+
+	// context-dependent commands check their own Runtime fields and report
+	// "unavailable" when the required capability is nil.
+	if response, handled := al.handleCommand(ctx, msg, agent, &opts); handled {
+		return response, nil
+	}
+
+	return al.runAgentLoop(ctx, agent, opts)
+}
+
+func (al *AgentLoop) resolveMessageRoute(msg bus.InboundMessage) (routing.ResolvedRoute, *AgentInstance, error) {
+	route := al.registry.ResolveRoute(routing.RouteInput{
+		Channel:    msg.Channel,
+		AccountID:  inboundMetadata(msg, metadataKeyAccountID),
+		Peer:       extractPeer(msg),
+		ParentPeer: extractParentPeer(msg),
+		GuildID:    inboundMetadata(msg, metadataKeyGuildID),
+		TeamID:     inboundMetadata(msg, metadataKeyTeamID),
+	})
+
+	agent, ok := al.registry.GetAgent(route.AgentID)
+	if !ok {
+		agent = al.registry.GetDefaultAgent()
+	}
+	if agent == nil {
+		return routing.ResolvedRoute{}, nil, fmt.Errorf("no agent available for route (agent_id=%s)", route.AgentID)
+	}
+
+	return route, agent, nil
+}
+
+func resolveScopeKey(route routing.ResolvedRoute, msgSessionKey string) string {
+	if msgSessionKey != "" && strings.HasPrefix(msgSessionKey, sessionKeyAgentPrefix) {
+		return msgSessionKey
+	}
+	return route.SessionKey
+}
+
+func (al *AgentLoop) processSystemMessage(
+	ctx context.Context,
+	msg bus.InboundMessage,
+) (string, error) {
+	if msg.Channel != "system" {
+		return "", fmt.Errorf(
+			"processSystemMessage called with non-system message channel: %s",
+			msg.Channel,
+		)
+	}
+
+	logger.InfoCF("agent", "Processing system message",
+		map[string]any{
+			"sender_id": msg.SenderID,
+			"chat_id":   msg.ChatID,
+		})
+
+	// Parse origin channel from chat_id (format: "channel:chat_id")
+	var originChannel, originChatID string
+	if idx := strings.Index(msg.ChatID, ":"); idx > 0 {
+		originChannel = msg.ChatID[:idx]
+		originChatID = msg.ChatID[idx+1:]
+	} else {
+		originChannel = "cli"
+		originChatID = msg.ChatID
+	}
+
+	// Extract subagent result from message content
+	// Format: "Task 'label' completed.\n\nResult:\n<actual content>"
+	content := msg.Content
+	if idx := strings.Index(content, "Result:\n"); idx >= 0 {
+		content = content[idx+8:] // Extract just the result part
+	}
+
+	// Skip internal channels - only log, don't send to user
+	if constants.IsInternalChannel(originChannel) {
+		logger.InfoCF("agent", "Subagent completed (internal channel)",
+			map[string]any{
+				"sender_id":   msg.SenderID,
+				"content_len": len(content),
+				"channel":     originChannel,
+			})
+		return "", nil
+	}
+
+	// Use default agent for system messages
+	agent := al.registry.GetDefaultAgent()
+	if agent == nil {
+		return "", fmt.Errorf("no default agent for system message")
+	}
+
+	// Use the origin session for context
+	sessionKey := routing.BuildAgentMainSessionKey(agent.ID)
+
+	return al.runAgentLoop(ctx, agent, processOptions{
+		SessionKey:      sessionKey,
+		Channel:         originChannel,
+		ChatID:          originChatID,
+		UserMessage:     fmt.Sprintf("[System: %s] %s", msg.SenderID, msg.Content),
+		DefaultResponse: "Background task completed.",
+		EnableSummary:   false,
+		SendResponse:    true,
+	})
+}
--- a/pkg/agent/loop_summary.go
+++ b/pkg/agent/loop_summary.go
@ -0,0 +1,311 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"jane/pkg/logger"
+	"jane/pkg/providers"
+)
+
+// maybeSummarize triggers summarization if the session history exceeds thresholds.
+func (al *AgentLoop) maybeSummarize(agent *AgentInstance, sessionKey, channel, chatID string) {
+	newHistory := agent.Sessions.GetHistory(sessionKey)
+	tokenEstimate := al.estimateTokens(newHistory)
+	threshold := agent.ContextWindow * agent.SummarizeTokenPercent / 100
+
+	if len(newHistory) > agent.SummarizeMessageThreshold || tokenEstimate > threshold {
+		summarizeKey := agent.ID + ":" + sessionKey
+		if _, loading := al.summarizing.LoadOrStore(summarizeKey, true); !loading {
+			go func() {
+				defer al.summarizing.Delete(summarizeKey)
+				logger.Debug("Memory threshold reached. Optimizing conversation history...")
+				al.summarizeSession(agent, sessionKey)
+			}()
+		}
+	}
+}
+
+// forceCompression aggressively reduces context when the limit is hit.
+// It drops the oldest 50% of messages (keeping system prompt and last user message).
+func (al *AgentLoop) forceCompression(agent *AgentInstance, sessionKey string) {
+	history := agent.Sessions.GetHistory(sessionKey)
+	if len(history) <= 4 {
+		return
+	}
+
+	// Keep system prompt (usually [0]) and the very last message (user's trigger)
+	// We want to drop the oldest half of the *conversation*
+	// Assuming [0] is system, [1:] is conversation
+	conversation := history[1 : len(history)-1]
+	if len(conversation) == 0 {
+		return
+	}
+
+	// Helper to find the mid-point of the conversation
+	mid := len(conversation) / 2
+
+	// New history structure:
+	// 1. System Prompt (with compression note appended)
+	// 2. Second half of conversation
+	// 3. Last message
+
+	droppedCount := mid
+	keptConversation := conversation[mid:]
+
+	newHistory := make([]providers.Message, 0, 1+len(keptConversation)+1)
+
+	// Append compression note to the original system prompt instead of adding a new system message
+	// This avoids having two consecutive system messages which some APIs (like Zhipu) reject
+	compressionNote := fmt.Sprintf(
+		"\n\n[System Note: Emergency compression dropped %d oldest messages due to context limit]",
+		droppedCount,
+	)
+	enhancedSystemPrompt := history[0]
+	enhancedSystemPrompt.Content = enhancedSystemPrompt.Content + compressionNote
+	newHistory = append(newHistory, enhancedSystemPrompt)
+
+	newHistory = append(newHistory, keptConversation...)
+	newHistory = append(newHistory, history[len(history)-1]) // Last message
+
+	// Update session
+	agent.Sessions.SetHistory(sessionKey, newHistory)
+	agent.Sessions.Save(sessionKey)
+
+	logger.WarnCF("agent", "Forced compression executed", map[string]any{
+		"session_key":  sessionKey,
+		"dropped_msgs": droppedCount,
+		"new_count":    len(newHistory),
+	})
+}
+
+// summarizeSession summarizes the conversation history for a session.
+func (al *AgentLoop) summarizeSession(agent *AgentInstance, sessionKey string) {
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+	defer cancel()
+
+	history := agent.Sessions.GetHistory(sessionKey)
+	summary := agent.Sessions.GetSummary(sessionKey)
+
+	// Keep last 4 messages for continuity
+	if len(history) <= 4 {
+		return
+	}
+
+	toSummarize := history[:len(history)-4]
+
+	// Oversized Message Guard
+	maxMessageTokens := agent.ContextWindow / 2
+	validMessages := make([]providers.Message, 0)
+	omitted := false
+
+	for _, m := range toSummarize {
+		if m.Role != "user" && m.Role != "assistant" {
+			continue
+		}
+		msgTokens := len(m.Content) / 2
+		if msgTokens > maxMessageTokens {
+			omitted = true
+			continue
+		}
+		validMessages = append(validMessages, m)
+	}
+
+	if len(validMessages) == 0 {
+		return
+	}
+
+	const (
+		maxSummarizationMessages = 10
+		llmMaxRetries            = 3
+		llmTemperature           = 0.3
+		fallbackMaxContentLength = 200
+	)
+
+	// Multi-Part Summarization
+	var finalSummary string
+	if len(validMessages) > maxSummarizationMessages {
+		mid := len(validMessages) / 2
+
+		mid = al.findNearestUserMessage(validMessages, mid)
+
+		part1 := validMessages[:mid]
+		part2 := validMessages[mid:]
+
+		s1, _ := al.summarizeBatch(ctx, agent, part1, "")
+		s2, _ := al.summarizeBatch(ctx, agent, part2, "")
+
+		mergePrompt := fmt.Sprintf(
+			"Merge these two conversation summaries into one cohesive summary:\n\n1: %s\n\n2: %s",
+			s1,
+			s2,
+		)
+
+		resp, err := al.retryLLMCall(ctx, agent, mergePrompt, llmMaxRetries)
+		if err == nil && resp.Content != "" {
+			finalSummary = resp.Content
+		} else {
+			finalSummary = s1 + " " + s2
+		}
+	} else {
+		finalSummary, _ = al.summarizeBatch(ctx, agent, validMessages, summary)
+	}
+
+	if omitted && finalSummary != "" {
+		finalSummary += "\n[Note: Some oversized messages were omitted from this summary for efficiency.]"
+	}
+
+	if finalSummary != "" {
+		agent.Sessions.SetSummary(sessionKey, finalSummary)
+		agent.Sessions.TruncateHistory(sessionKey, 4)
+		agent.Sessions.Save(sessionKey)
+	}
+}
+
+// findNearestUserMessage finds the nearest user message to the given index.
+// It searches backward first, then forward if no user message is found.
+func (al *AgentLoop) findNearestUserMessage(messages []providers.Message, mid int) int {
+	originalMid := mid
+
+	for mid > 0 && messages[mid].Role != "user" {
+		mid--
+	}
+
+	if messages[mid].Role == "user" {
+		return mid
+	}
+
+	mid = originalMid
+	for mid < len(messages) && messages[mid].Role != "user" {
+		mid++
+	}
+
+	if mid < len(messages) {
+		return mid
+	}
+
+	return originalMid
+}
+
+// retryLLMCall calls the LLM with retry logic.
+func (al *AgentLoop) retryLLMCall(
+	ctx context.Context,
+	agent *AgentInstance,
+	prompt string,
+	maxRetries int,
+) (*providers.LLMResponse, error) {
+	const (
+		llmTemperature = 0.3
+	)
+
+	var resp *providers.LLMResponse
+	var err error
+
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		resp, err = agent.Provider.Chat(
+			ctx,
+			[]providers.Message{{Role: "user", Content: prompt}},
+			nil,
+			agent.Model,
+			map[string]any{
+				"max_tokens":       agent.MaxTokens,
+				"temperature":      llmTemperature,
+				"prompt_cache_key": agent.ID,
+			},
+		)
+		if err == nil && resp != nil && resp.Content != "" {
+			return resp, nil
+		}
+		if attempt < maxRetries-1 {
+			time.Sleep(time.Duration(attempt+1) * 100 * time.Millisecond)
+		}
+	}
+
+	return resp, err
+}
+
+// summarizeBatch summarizes a batch of messages.
+func (al *AgentLoop) summarizeBatch(
+	ctx context.Context,
+	agent *AgentInstance,
+	batch []providers.Message,
+	existingSummary string,
+) (string, error) {
+	const (
+		llmMaxRetries             = 3
+		llmTemperature            = 0.3
+		fallbackMinContentLength  = 200
+		fallbackMaxContentPercent = 10
+	)
+
+	var sb strings.Builder
+	sb.WriteString(
+		"Provide a concise summary of this conversation segment, preserving core context and key points.\n",
+	)
+	if existingSummary != "" {
+		sb.WriteString("Existing context: ")
+		sb.WriteString(existingSummary)
+		sb.WriteString("\n")
+	}
+	sb.WriteString("\nCONVERSATION:\n")
+	for _, m := range batch {
+		fmt.Fprintf(&sb, "%s: %s\n", m.Role, m.Content)
+	}
+	prompt := sb.String()
+
+	response, err := al.retryLLMCall(ctx, agent, prompt, llmMaxRetries)
+	if err == nil && response.Content != "" {
+		return strings.TrimSpace(response.Content), nil
+	}
+
+	var fallback strings.Builder
+	fallback.WriteString("Conversation summary: ")
+	for i, m := range batch {
+		if i > 0 {
+			fallback.WriteString(" | ")
+		}
+		content := strings.TrimSpace(m.Content)
+		runes := []rune(content)
+		if len(runes) == 0 {
+			fallback.WriteString(fmt.Sprintf("%s: ", m.Role))
+			continue
+		}
+
+		keepLength := len(runes) * fallbackMaxContentPercent / 100
+		if keepLength < fallbackMinContentLength {
+			keepLength = fallbackMinContentLength
+		}
+
+		if keepLength > len(runes) {
+			keepLength = len(runes)
+		}
+
+		content = string(runes[:keepLength])
+		if keepLength < len(runes) {
+			content += "..."
+		}
+		fallback.WriteString(fmt.Sprintf("%s: %s", m.Role, content))
+	}
+	return fallback.String(), nil
+}
+
+// estimateTokens estimates the number of tokens in a message list.
+// Uses a safe heuristic of 2.5 characters per token to account for CJK and other
+// overheads better than the previous 3 chars/token.
+func (al *AgentLoop) estimateTokens(messages []providers.Message) int {
+	totalChars := 0
+	for _, m := range messages {
+		totalChars += utf8.RuneCountInString(m.Content)
+	}
+	// 2.5 chars per token = totalChars * 2 / 5
+	return totalChars * 2 / 5
+}
--- a/pkg/agent/loop_test.go
+++ b/pkg/agent/loop_test.go
@ -846,7 +846,6 @@ func TestTargetReasoningChannelID_AllChannels(t *testing.T) {
 	for name, id := range map[string]string{
 		"whatsapp":  "rid-whatsapp",
 		"telegram":  "rid-telegram",
-		"feishu":    "rid-feishu",
 		"discord":   "rid-discord",
 		"maixcam":   "rid-maixcam",
 		"qq":        "rid-qq",
@ -864,7 +863,6 @@ func TestTargetReasoningChannelID_AllChannels(t *testing.T) {
 	}{
 		{channel: "whatsapp", wantID: "rid-whatsapp"},
 		{channel: "telegram", wantID: "rid-telegram"},
-		{channel: "feishu", wantID: "rid-feishu"},
 		{channel: "discord", wantID: "rid-discord"},
 		{channel: "maixcam", wantID: "rid-maixcam"},
 		{channel: "qq", wantID: "rid-qq"},
--- a/pkg/agent/loop_utils.go
+++ b/pkg/agent/loop_utils.go
@ -0,0 +1,140 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// Inspired by and based on nanobot: https://github.com/HKUDS/nanobot
+// License: MIT
+//
+// Copyright (c) 2026 PicoClaw contributors
+
+package agent
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"jane/pkg/bus"
+	"jane/pkg/providers"
+	"jane/pkg/routing"
+	"jane/pkg/utils"
+)
+
+// formatMessagesForLog formats messages for logging
+func formatMessagesForLog(messages []providers.Message) string {
+	if len(messages) == 0 {
+		return "[]"
+	}
+
+	var sb strings.Builder
+	sb.WriteString("[\n")
+	for i, msg := range messages {
+		fmt.Fprintf(&sb, "  [%d] Role: %s\n", i, msg.Role)
+		if len(msg.ToolCalls) > 0 {
+			sb.WriteString("  ToolCalls:\n")
+			for _, tc := range msg.ToolCalls {
+				fmt.Fprintf(&sb, "    - ID: %s, Type: %s, Name: %s\n", tc.ID, tc.Type, tc.Name)
+				if tc.Function != nil {
+					fmt.Fprintf(
+						&sb,
+						"      Arguments: %s\n",
+						utils.Truncate(tc.Function.Arguments, 200),
+					)
+				}
+			}
+		}
+		if msg.Content != "" {
+			content := utils.Truncate(msg.Content, 200)
+			fmt.Fprintf(&sb, "  Content: %s\n", content)
+		}
+		if msg.ToolCallID != "" {
+			fmt.Fprintf(&sb, "  ToolCallID: %s\n", msg.ToolCallID)
+		}
+		sb.WriteString("\n")
+	}
+	sb.WriteString("]")
+	return sb.String()
+}
+
+// formatToolsForLog formats tool definitions for logging
+func formatToolsForLog(toolDefs []providers.ToolDefinition) string {
+	if len(toolDefs) == 0 {
+		return "[]"
+	}
+
+	var sb strings.Builder
+	sb.WriteString("[\n")
+	for i, tool := range toolDefs {
+		fmt.Fprintf(&sb, "  [%d] Type: %s, Name: %s\n", i, tool.Type, tool.Function.Name)
+		fmt.Fprintf(&sb, "      Description: %s\n", tool.Function.Description)
+		if len(tool.Function.Parameters) > 0 {
+			fmt.Fprintf(
+				&sb,
+				"      Parameters: %s\n",
+				utils.Truncate(fmt.Sprintf("%v", tool.Function.Parameters), 200),
+			)
+		}
+	}
+	sb.WriteString("]")
+	return sb.String()
+}
+
+// inferMediaType determines the media type ("image", "audio", "video", "file")
+// from a filename and MIME content type.
+func inferMediaType(filename, contentType string) string {
+	ct := strings.ToLower(contentType)
+	fn := strings.ToLower(filename)
+
+	if strings.HasPrefix(ct, "image/") {
+		return "image"
+	}
+	if strings.HasPrefix(ct, "audio/") || ct == "application/ogg" {
+		return "audio"
+	}
+	if strings.HasPrefix(ct, "video/") {
+		return "video"
+	}
+
+	// Fallback: infer from extension
+	ext := filepath.Ext(fn)
+	switch ext {
+	case ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg":
+		return "image"
+	case ".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac", ".wma", ".opus":
+		return "audio"
+	case ".mp4", ".avi", ".mov", ".webm", ".mkv":
+		return "video"
+	}
+
+	return "file"
+}
+
+// extractPeer extracts the routing peer from the inbound message's structured Peer field.
+func extractPeer(msg bus.InboundMessage) *routing.RoutePeer {
+	if msg.Peer.Kind == "" {
+		return nil
+	}
+	peerID := msg.Peer.ID
+	if peerID == "" {
+		if msg.Peer.Kind == "direct" {
+			peerID = msg.SenderID
+		} else {
+			peerID = msg.ChatID
+		}
+	}
+	return &routing.RoutePeer{Kind: msg.Peer.Kind, ID: peerID}
+}
+
+func inboundMetadata(msg bus.InboundMessage, key string) string {
+	if msg.Metadata == nil {
+		return ""
+	}
+	return msg.Metadata[key]
+}
+
+// extractParentPeer extracts the parent peer (reply-to) from inbound message metadata.
+func extractParentPeer(msg bus.InboundMessage) *routing.RoutePeer {
+	parentKind := inboundMetadata(msg, metadataKeyParentPeerKind)
+	parentID := inboundMetadata(msg, metadataKeyParentPeerID)
+	if parentKind == "" || parentID == "" {
+		return nil
+	}
+	return &routing.RoutePeer{Kind: parentKind, ID: parentID}
+}
--- a/pkg/auth/oauth.go
+++ b/pkg/auth/oauth.go
@ -118,7 +118,12 @@ func LoginBrowser(cfg OAuthProviderConfig) (*AuthCredential, error) {
 		return nil, fmt.Errorf("starting callback server on port %d: %w", cfg.Port, err)
 	}

-	server := &http.Server{Handler: mux}
+	server := &http.Server{
+		Handler:           mux,
+		ReadTimeout:       10 * time.Second,
+		ReadHeaderTimeout: 5 * time.Second,
+		WriteTimeout:      10 * time.Second,
+	}
 	go server.Serve(listener)
 	defer func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
--- a/pkg/channels/README.md
+++ b/pkg/channels/README.md
@ -60,7 +60,7 @@ pkg/channels/
 ├── discord/
 │   ├── init.go
 │   └── discord.go
-├── slack/ line/ onebot/ dingtalk/ feishu/ qq/ whatsapp/ whatsapp_native/ maixcam/ pico/
+├── slack/ line/ onebot/ dingtalk/ qq/ whatsapp/ whatsapp_native/ maixcam/ pico/
 │   └── ...

 pkg/bus/
@ -1254,7 +1254,6 @@ make test                                       # Full test suite
 | `pkg/channels/line/` | `"line"` | TypingCapable, MediaSender, WebhookHandler |
 | `pkg/channels/onebot/` | `"onebot"` | ReactionCapable, MediaSender |
 | `pkg/channels/dingtalk/` | `"dingtalk"` | — |
-| `pkg/channels/feishu/` | `"feishu"` | — (architecture-specific build tags: `feishu_32.go` / `feishu_64.go`) |
 | `pkg/channels/qq/` | `"qq"` | — |
 | `pkg/channels/whatsapp/` | `"whatsapp"` | — (Bridge mode) |
 | `pkg/channels/whatsapp_native/` | `"whatsapp_native"` | — (Native whatsmeow mode) |
@ -1367,7 +1366,6 @@ agentLoop.Stop()               // Stop Agent

 1. **Media cleanup temporarily disabled**: The `ReleaseAll` call in the Agent loop is commented out (`refactor(loop): disable media cleanup to prevent premature file deletion`) because session boundaries are not yet clearly defined. TTL cleanup remains active.

-2. **Feishu architecture-specific compilation**: The Feishu channel uses build tags to distinguish 32-bit and 64-bit architectures (`feishu_32.go` / `feishu_64.go`). Feishu uses the SDK's WebSocket mode (not HTTP webhook), so it does not implement `WebhookHandler`.


 4. **Pico Protocol**: `pkg/channels/pico/` implements a custom PicoClaw native protocol channel that receives messages via WebSocket webhook (`/pico/ws`).
@ -1378,4 +1376,4 @@ agentLoop.Stop()               // Stop Agent

 7. **PlaceholderConfig vs implementation**: `PlaceholderConfig` appears in 6 channel configs (Telegram, Discord, Slack, LINE, OneBot, Pico), but only channels that implement both `PlaceholderCapable` + `MessageEditor` (Telegram, Discord, Pico) can actually use placeholder message editing. The rest are reserved fields.

-8. **ReasoningChannelID**: Most channel configs include a `reasoning_channel_id` field to route LLM reasoning/thinking output to a designated channel (WhatsApp, Telegram, Feishu, Discord, MaixCam, QQ, DingTalk, Slack, LINE, OneBot). Note: `PicoConfig` does not currently expose this field. `BaseChannel` exposes this via the `WithReasoningChannelID` option and `ReasoningChannelID()` method.
+8. **ReasoningChannelID**: Most channel configs include a `reasoning_channel_id` field to route LLM reasoning/thinking output to a designated channel (WhatsApp, Telegram, Discord, MaixCam, QQ, DingTalk, Slack, LINE, OneBot). Note: `PicoConfig` does not currently expose this field. `BaseChannel` exposes this via the `WithReasoningChannelID` option and `ReasoningChannelID()` method.
--- a/pkg/channels/README.zh.md
+++ b/pkg/channels/README.zh.md
@ -60,7 +60,7 @@ pkg/channels/
 ├── discord/
 │   ├── init.go
 │   └── discord.go
-├── slack/ line/ onebot/ dingtalk/ feishu/ qq/ whatsapp/ whatsapp_native/ maixcam/ pico/
+├── slack/ line/ onebot/ dingtalk/ qq/ whatsapp/ whatsapp_native/ maixcam/ pico/
 │   └── ...

 pkg/bus/
@ -1253,7 +1253,6 @@ make test                                       # 全量测试
 | `pkg/channels/line/` | `"line"` | TypingCapable, MediaSender, WebhookHandler |
 | `pkg/channels/onebot/` | `"onebot"` | ReactionCapable, MediaSender |
 | `pkg/channels/dingtalk/` | `"dingtalk"` | — |
-| `pkg/channels/feishu/` | `"feishu"` | — (架构特定 build tags: `feishu_32.go` / `feishu_64.go`) |
 | `pkg/channels/qq/` | `"qq"` | — |
 | `pkg/channels/whatsapp/` | `"whatsapp"` | — (Bridge 模式) |
 | `pkg/channels/whatsapp_native/` | `"whatsapp_native"` | — (原生 whatsmeow 模式) |
@ -1366,7 +1365,6 @@ agentLoop.Stop()               // 停止 Agent

 1. **媒体清理暂时禁用**：Agent loop 中的 `ReleaseAll` 调用被注释掉了（`refactor(loop): disable media cleanup to prevent premature file deletion`），因为会话边界尚未明确定义。TTL 清理仍然有效。

-2. **Feishu 架构特定编译**：Feishu channel 使用 build tags 区分 32 位和 64 位架构（`feishu_32.go` / `feishu_64.go`）。Feishu 使用 SDK 的 WebSocket 模式（非 HTTP webhook），因此不实现 `WebhookHandler`。


 4. **Pico Protocol**：`pkg/channels/pico/` 实现了一个自定义的 PicoClaw 原生协议 channel，通过 WebSocket webhook (`/pico/ws`) 接收消息。
@ -1377,4 +1375,4 @@ agentLoop.Stop()               // 停止 Agent

 7. **PlaceholderConfig 的配置与实现**：`PlaceholderConfig` 出现在 6 个 channel config 中（Telegram、Discord、Slack、LINE、OneBot、Pico），但只有实现了 `PlaceholderCapable` + `MessageEditor` 的 channel（Telegram、Discord、Pico）能真正使用占位消息编辑功能。其余 channel 的 `PlaceholderConfig` 为预留字段。

-8. **ReasoningChannelID**：大多数 channel config 都包含 `reasoning_channel_id` 字段，用于将 LLM 的思维链（reasoning/thinking）路由到指定 channel（WhatsApp、Telegram、Feishu、Discord、MaixCam、QQ、DingTalk、Slack、LINE、OneBot）。注意：`PicoConfig` 目前不包含该字段。`BaseChannel` 通过 `WithReasoningChannelID` 选项和 `ReasoningChannelID()` 方法暴露此配置。
+8. **ReasoningChannelID**：大多数 channel config 都包含 `reasoning_channel_id` 字段，用于将 LLM 的思维链（reasoning/thinking）路由到指定 channel（WhatsApp、Telegram、Discord、MaixCam、QQ、DingTalk、Slack、LINE、OneBot）。注意：`PicoConfig` 目前不包含该字段。`BaseChannel` 通过 `WithReasoningChannelID` 选项和 `ReasoningChannelID()` 方法暴露此配置。
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@ -406,6 +406,8 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		return localPath // fallback
 	}

+	var contentBuilder strings.Builder
+	contentBuilder.WriteString(content)
 	for _, attachment := range m.Attachments {
 		isAudio := utils.IsAudioFile(attachment.Filename, attachment.ContentType)

@ -413,21 +415,36 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 			localPath := c.downloadAttachment(attachment.URL, attachment.Filename)
 			if localPath != "" {
 				mediaPaths = append(mediaPaths, storeMedia(localPath, attachment.Filename))
-				content = appendContent(content, fmt.Sprintf("[audio: %s]", attachment.Filename))
+				if contentBuilder.Len() > 0 {
+					contentBuilder.WriteByte('\n')
+				}
+				contentBuilder.WriteString("[audio: ")
+				contentBuilder.WriteString(attachment.Filename)
+				contentBuilder.WriteByte(']')
 			} else {
 				logger.WarnCF("discord", "Failed to download audio attachment", map[string]any{
 					"url":      attachment.URL,
 					"filename": attachment.Filename,
 				})
 				mediaPaths = append(mediaPaths, attachment.URL)
-				content = appendContent(content, fmt.Sprintf("[attachment: %s]", attachment.URL))
+				if contentBuilder.Len() > 0 {
+					contentBuilder.WriteByte('\n')
+				}
+				contentBuilder.WriteString("[attachment: ")
+				contentBuilder.WriteString(attachment.URL)
+				contentBuilder.WriteByte(']')
 			}
 		} else {
 			mediaPaths = append(mediaPaths, attachment.URL)
-			content = appendContent(content, fmt.Sprintf("[attachment: %s]", attachment.URL))
+			if contentBuilder.Len() > 0 {
+				contentBuilder.WriteByte('\n')
+			}
+			contentBuilder.WriteString("[attachment: ")
+			contentBuilder.WriteString(attachment.URL)
+			contentBuilder.WriteByte(']')
 		}
 	}
-
+	content = contentBuilder.String()
 	if content == "" && len(mediaPaths) == 0 {
 		return
 	}
@ -600,7 +617,10 @@ func (c *DiscordChannel) resolveDiscordRefs(s *discordgo.Session, text string, g
 		if msg.Author != nil {
 			author = msg.Author.Username
 		}
-		fmt.Fprintf(&sb, "\n[linked message from %s]: %s", author, msg.Content)
+		sb.WriteString("\n[linked message from ")
+		sb.WriteString(author)
+		sb.WriteString("]: ")
+		sb.WriteString(msg.Content)
 	}

 	return sb.String()
--- a/pkg/channels/feishu/common.go
+++ b/pkg/channels/feishu/common.go
@ -1,86 +0,0 @@
-package feishu
-
-import (
-	"encoding/json"
-	"regexp"
-	"strings"
-
-	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
-)
-
-// mentionPlaceholderRegex matches @_user_N placeholders inserted by Feishu for mentions.
-var mentionPlaceholderRegex = regexp.MustCompile(`@_user_\d+`)
-
-// stringValue safely dereferences a *string pointer.
-func stringValue(v *string) string {
-	if v == nil {
-		return ""
-	}
-	return *v
-}
-
-// buildMarkdownCard builds a Feishu Interactive Card JSON 2.0 string with markdown content.
-// JSON 2.0 cards support full CommonMark standard markdown syntax.
-func buildMarkdownCard(content string) (string, error) {
-	card := map[string]any{
-		"schema": "2.0",
-		"body": map[string]any{
-			"elements": []map[string]any{
-				{
-					"tag":     "markdown",
-					"content": content,
-				},
-			},
-		},
-	}
-	data, err := json.Marshal(card)
-	if err != nil {
-		return "", err
-	}
-	return string(data), nil
-}
-
-// extractJSONStringField unmarshals content as JSON and returns the value of the given string field.
-// Returns "" if the content is invalid JSON or the field is missing/empty.
-func extractJSONStringField(content, field string) string {
-	var m map[string]json.RawMessage
-	if err := json.Unmarshal([]byte(content), &m); err != nil {
-		return ""
-	}
-	raw, ok := m[field]
-	if !ok {
-		return ""
-	}
-	var s string
-	if err := json.Unmarshal(raw, &s); err != nil {
-		return ""
-	}
-	return s
-}
-
-// extractImageKey extracts the image_key from a Feishu image message content JSON.
-// Format: {"image_key": "img_xxx"}
-func extractImageKey(content string) string { return extractJSONStringField(content, "image_key") }
-
-// extractFileKey extracts the file_key from a Feishu file/audio message content JSON.
-// Format: {"file_key": "file_xxx", "file_name": "...", ...}
-func extractFileKey(content string) string { return extractJSONStringField(content, "file_key") }
-
-// extractFileName extracts the file_name from a Feishu file message content JSON.
-func extractFileName(content string) string { return extractJSONStringField(content, "file_name") }
-
-// stripMentionPlaceholders removes @_user_N placeholders from the text content.
-// These are inserted by Feishu when users @mention someone in a message.
-func stripMentionPlaceholders(content string, mentions []*larkim.MentionEvent) string {
-	if len(mentions) == 0 {
-		return content
-	}
-	for _, m := range mentions {
-		if m.Key != nil && *m.Key != "" {
-			content = strings.ReplaceAll(content, *m.Key, "")
-		}
-	}
-	// Also clean up any remaining @_user_N patterns
-	content = mentionPlaceholderRegex.ReplaceAllString(content, "")
-	return strings.TrimSpace(content)
-}
--- a/pkg/channels/feishu/common_test.go
+++ b/pkg/channels/feishu/common_test.go
@ -1,292 +0,0 @@
-package feishu
-
-import (
-	"encoding/json"
-	"testing"
-
-	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
-)
-
-func TestExtractJSONStringField(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-		field   string
-		want    string
-	}{
-		{
-			name:    "valid field",
-			content: `{"image_key": "img_v2_xxx"}`,
-			field:   "image_key",
-			want:    "img_v2_xxx",
-		},
-		{
-			name:    "missing field",
-			content: `{"image_key": "img_v2_xxx"}`,
-			field:   "file_key",
-			want:    "",
-		},
-		{
-			name:    "invalid JSON",
-			content: `not json at all`,
-			field:   "image_key",
-			want:    "",
-		},
-		{
-			name:    "empty content",
-			content: "",
-			field:   "image_key",
-			want:    "",
-		},
-		{
-			name:    "non-string field value",
-			content: `{"count": 42}`,
-			field:   "count",
-			want:    "",
-		},
-		{
-			name:    "empty string value",
-			content: `{"image_key": ""}`,
-			field:   "image_key",
-			want:    "",
-		},
-		{
-			name:    "multiple fields",
-			content: `{"file_key": "file_xxx", "file_name": "test.pdf"}`,
-			field:   "file_name",
-			want:    "test.pdf",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractJSONStringField(tt.content, tt.field)
-			if got != tt.want {
-				t.Errorf("extractJSONStringField(%q, %q) = %q, want %q", tt.content, tt.field, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestExtractImageKey(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-		want    string
-	}{
-		{
-			name:    "normal",
-			content: `{"image_key": "img_v2_abc123"}`,
-			want:    "img_v2_abc123",
-		},
-		{
-			name:    "missing key",
-			content: `{"file_key": "file_xxx"}`,
-			want:    "",
-		},
-		{
-			name:    "malformed JSON",
-			content: `{broken`,
-			want:    "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractImageKey(tt.content)
-			if got != tt.want {
-				t.Errorf("extractImageKey(%q) = %q, want %q", tt.content, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestExtractFileKey(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-		want    string
-	}{
-		{
-			name:    "normal",
-			content: `{"file_key": "file_v2_abc123", "file_name": "test.doc"}`,
-			want:    "file_v2_abc123",
-		},
-		{
-			name:    "missing key",
-			content: `{"image_key": "img_xxx"}`,
-			want:    "",
-		},
-		{
-			name:    "malformed JSON",
-			content: `not json`,
-			want:    "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractFileKey(tt.content)
-			if got != tt.want {
-				t.Errorf("extractFileKey(%q) = %q, want %q", tt.content, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestExtractFileName(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-		want    string
-	}{
-		{
-			name:    "normal",
-			content: `{"file_key": "file_xxx", "file_name": "report.pdf"}`,
-			want:    "report.pdf",
-		},
-		{
-			name:    "missing name",
-			content: `{"file_key": "file_xxx"}`,
-			want:    "",
-		},
-		{
-			name:    "malformed JSON",
-			content: `{bad`,
-			want:    "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractFileName(tt.content)
-			if got != tt.want {
-				t.Errorf("extractFileName(%q) = %q, want %q", tt.content, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestBuildMarkdownCard(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-	}{
-		{
-			name:    "normal content",
-			content: "Hello **world**",
-		},
-		{
-			name:    "empty content",
-			content: "",
-		},
-		{
-			name:    "special characters",
-			content: `Code: "foo" & <bar> 'baz'`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := buildMarkdownCard(tt.content)
-			if err != nil {
-				t.Fatalf("buildMarkdownCard(%q) unexpected error: %v", tt.content, err)
-			}
-
-			// Verify valid JSON
-			var parsed map[string]any
-			if err := json.Unmarshal([]byte(result), &parsed); err != nil {
-				t.Fatalf("buildMarkdownCard(%q) produced invalid JSON: %v", tt.content, err)
-			}
-
-			// Verify schema
-			if parsed["schema"] != "2.0" {
-				t.Errorf("schema = %v, want %q", parsed["schema"], "2.0")
-			}
-
-			// Verify body.elements[0].content == input
-			body, ok := parsed["body"].(map[string]any)
-			if !ok {
-				t.Fatal("missing body in card JSON")
-			}
-			elements, ok := body["elements"].([]any)
-			if !ok || len(elements) == 0 {
-				t.Fatal("missing or empty elements in card JSON")
-			}
-			elem, ok := elements[0].(map[string]any)
-			if !ok {
-				t.Fatal("first element is not an object")
-			}
-			if elem["tag"] != "markdown" {
-				t.Errorf("tag = %v, want %q", elem["tag"], "markdown")
-			}
-			if elem["content"] != tt.content {
-				t.Errorf("content = %v, want %q", elem["content"], tt.content)
-			}
-		})
-	}
-}
-
-func TestStripMentionPlaceholders(t *testing.T) {
-	strPtr := func(s string) *string { return &s }
-
-	tests := []struct {
-		name     string
-		content  string
-		mentions []*larkim.MentionEvent
-		want     string
-	}{
-		{
-			name:     "no mentions",
-			content:  "Hello world",
-			mentions: nil,
-			want:     "Hello world",
-		},
-		{
-			name:    "single mention",
-			content: "@_user_1 hello",
-			mentions: []*larkim.MentionEvent{
-				{Key: strPtr("@_user_1")},
-			},
-			want: "hello",
-		},
-		{
-			name:    "multiple mentions",
-			content: "@_user_1 @_user_2 hey",
-			mentions: []*larkim.MentionEvent{
-				{Key: strPtr("@_user_1")},
-				{Key: strPtr("@_user_2")},
-			},
-			want: "hey",
-		},
-		{
-			name:     "empty content",
-			content:  "",
-			mentions: []*larkim.MentionEvent{{Key: strPtr("@_user_1")}},
-			want:     "",
-		},
-		{
-			name:     "empty mentions slice",
-			content:  "@_user_1 test",
-			mentions: []*larkim.MentionEvent{},
-			want:     "@_user_1 test",
-		},
-		{
-			name:    "mention with nil key",
-			content: "@_user_1 test",
-			mentions: []*larkim.MentionEvent{
-				{Key: nil},
-			},
-			want: "test",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := stripMentionPlaceholders(tt.content, tt.mentions)
-			if got != tt.want {
-				t.Errorf("stripMentionPlaceholders(%q, ...) = %q, want %q", tt.content, got, tt.want)
-			}
-		})
-	}
-}
--- a/pkg/channels/feishu/feishu_32.go
+++ b/pkg/channels/feishu/feishu_32.go
@ -1,61 +0,0 @@
-//go:build !amd64 && !arm64 && !riscv64 && !mips64 && !ppc64
-
-package feishu
-
-import (
-	"context"
-	"errors"
-
-	"jane/pkg/bus"
-	"jane/pkg/channels"
-	"jane/pkg/config"
-)
-
-// FeishuChannel is a stub implementation for 32-bit architectures
-type FeishuChannel struct {
-	*channels.BaseChannel
-}
-
-var errUnsupported = errors.New("feishu channel is not supported on 32-bit architectures")
-
-// NewFeishuChannel returns an error on 32-bit architectures where the Feishu SDK is not supported
-func NewFeishuChannel(cfg config.FeishuConfig, bus *bus.MessageBus) (*FeishuChannel, error) {
-	return nil, errors.New(
-		"feishu channel is not supported on 32-bit architectures (armv7l, 386, etc.). Please use a 64-bit system or disable feishu in your config",
-	)
-}
-
-// Start is a stub method to satisfy the Channel interface
-func (c *FeishuChannel) Start(ctx context.Context) error {
-	return errUnsupported
-}
-
-// Stop is a stub method to satisfy the Channel interface
-func (c *FeishuChannel) Stop(ctx context.Context) error {
-	return errUnsupported
-}
-
-// Send is a stub method to satisfy the Channel interface
-func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	return errUnsupported
-}
-
-// EditMessage is a stub method to satisfy MessageEditor
-func (c *FeishuChannel) EditMessage(ctx context.Context, chatID, messageID, content string) error {
-	return errUnsupported
-}
-
-// SendPlaceholder is a stub method to satisfy PlaceholderCapable
-func (c *FeishuChannel) SendPlaceholder(ctx context.Context, chatID string) (string, error) {
-	return "", errUnsupported
-}
-
-// ReactToMessage is a stub method to satisfy ReactionCapable
-func (c *FeishuChannel) ReactToMessage(ctx context.Context, chatID, messageID string) (func(), error) {
-	return func() {}, errUnsupported
-}
-
-// SendMedia is a stub method to satisfy MediaSender
-func (c *FeishuChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
-	return errUnsupported
-}
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@ -1,832 +0,0 @@
-//go:build amd64 || arm64 || riscv64 || mips64 || ppc64
-
-package feishu
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math/rand"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-
-	lark "github.com/larksuite/oapi-sdk-go/v3"
-	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
-	larkdispatcher "github.com/larksuite/oapi-sdk-go/v3/event/dispatcher"
-	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
-	larkws "github.com/larksuite/oapi-sdk-go/v3/ws"
-
-	"jane/pkg/bus"
-	"jane/pkg/channels"
-	"jane/pkg/config"
-	"jane/pkg/identity"
-	"jane/pkg/logger"
-	"jane/pkg/media"
-	"jane/pkg/utils"
-)
-
-type FeishuChannel struct {
-	*channels.BaseChannel
-	config   config.FeishuConfig
-	client   *lark.Client
-	wsClient *larkws.Client
-
-	botOpenID atomic.Value // stores string; populated lazily for @mention detection
-
-	mu     sync.Mutex
-	cancel context.CancelFunc
-}
-
-func NewFeishuChannel(cfg config.FeishuConfig, bus *bus.MessageBus) (*FeishuChannel, error) {
-	base := channels.NewBaseChannel("feishu", cfg, bus, cfg.AllowFrom,
-		channels.WithGroupTrigger(cfg.GroupTrigger),
-		channels.WithReasoningChannelID(cfg.ReasoningChannelID),
-	)
-
-	ch := &FeishuChannel{
-		BaseChannel: base,
-		config:      cfg,
-		client:      lark.NewClient(cfg.AppID, cfg.AppSecret),
-	}
-	ch.SetOwner(ch)
-	return ch, nil
-}
-
-func (c *FeishuChannel) Start(ctx context.Context) error {
-	if c.config.AppID == "" || c.config.AppSecret == "" {
-		return fmt.Errorf("feishu app_id or app_secret is empty")
-	}
-
-	// Fetch bot open_id via API for reliable @mention detection.
-	if err := c.fetchBotOpenID(ctx); err != nil {
-		logger.ErrorCF("feishu", "Failed to fetch bot open_id, @mention detection may not work", map[string]any{
-			"error": err.Error(),
-		})
-	}
-
-	dispatcher := larkdispatcher.NewEventDispatcher(c.config.VerificationToken, c.config.EncryptKey).
-		OnP2MessageReceiveV1(c.handleMessageReceive)
-
-	runCtx, cancel := context.WithCancel(ctx)
-
-	c.mu.Lock()
-	c.cancel = cancel
-	c.wsClient = larkws.NewClient(
-		c.config.AppID,
-		c.config.AppSecret,
-		larkws.WithEventHandler(dispatcher),
-	)
-	wsClient := c.wsClient
-	c.mu.Unlock()
-
-	c.SetRunning(true)
-	logger.InfoC("feishu", "Feishu channel started (websocket mode)")
-
-	go func() {
-		if err := wsClient.Start(runCtx); err != nil {
-			logger.ErrorCF("feishu", "Feishu websocket stopped with error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
-
-	return nil
-}
-
-func (c *FeishuChannel) Stop(ctx context.Context) error {
-	c.mu.Lock()
-	if c.cancel != nil {
-		c.cancel()
-		c.cancel = nil
-	}
-	c.wsClient = nil
-	c.mu.Unlock()
-
-	c.SetRunning(false)
-	logger.InfoC("feishu", "Feishu channel stopped")
-	return nil
-}
-
-// Send sends a message using Interactive Card format for markdown rendering.
-func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return channels.ErrNotRunning
-	}
-
-	if msg.ChatID == "" {
-		return fmt.Errorf("chat ID is empty: %w", channels.ErrSendFailed)
-	}
-
-	// Build interactive card with markdown content
-	cardContent, err := buildMarkdownCard(msg.Content)
-	if err != nil {
-		return fmt.Errorf("feishu send: card build failed: %w", err)
-	}
-	return c.sendCard(ctx, msg.ChatID, cardContent)
-}
-
-// EditMessage implements channels.MessageEditor.
-// Uses Message.Patch to update an interactive card message.
-func (c *FeishuChannel) EditMessage(ctx context.Context, chatID, messageID, content string) error {
-	cardContent, err := buildMarkdownCard(content)
-	if err != nil {
-		return fmt.Errorf("feishu edit: card build failed: %w", err)
-	}
-
-	req := larkim.NewPatchMessageReqBuilder().
-		MessageId(messageID).
-		Body(larkim.NewPatchMessageReqBodyBuilder().Content(cardContent).Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Patch(ctx, req)
-	if err != nil {
-		return fmt.Errorf("feishu edit: %w", err)
-	}
-	if !resp.Success() {
-		return fmt.Errorf("feishu edit api error (code=%d msg=%s)", resp.Code, resp.Msg)
-	}
-	return nil
-}
-
-// SendPlaceholder implements channels.PlaceholderCapable.
-// Sends an interactive card with placeholder text and returns its message ID.
-func (c *FeishuChannel) SendPlaceholder(ctx context.Context, chatID string) (string, error) {
-	if !c.config.Placeholder.Enabled {
-		logger.DebugCF("feishu", "Placeholder disabled, skipping", map[string]any{
-			"chat_id": chatID,
-		})
-		return "", nil
-	}
-
-	text := c.config.Placeholder.Text
-	if text == "" {
-		text = "Thinking..."
-	}
-
-	cardContent, err := buildMarkdownCard(text)
-	if err != nil {
-		return "", fmt.Errorf("feishu placeholder: card build failed: %w", err)
-	}
-
-	req := larkim.NewCreateMessageReqBuilder().
-		ReceiveIdType(larkim.ReceiveIdTypeChatId).
-		Body(larkim.NewCreateMessageReqBodyBuilder().
-			ReceiveId(chatID).
-			MsgType(larkim.MsgTypeInteractive).
-			Content(cardContent).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Create(ctx, req)
-	if err != nil {
-		return "", fmt.Errorf("feishu placeholder send: %w", err)
-	}
-	if !resp.Success() {
-		return "", fmt.Errorf("feishu placeholder api error (code=%d msg=%s)", resp.Code, resp.Msg)
-	}
-
-	if resp.Data != nil && resp.Data.MessageId != nil {
-		return *resp.Data.MessageId, nil
-	}
-	return "", nil
-}
-
-// ReactToMessage implements channels.ReactionCapable.
-// Adds a reaction (randomly chosen from config) and returns an undo function to remove it.
-func (c *FeishuChannel) ReactToMessage(ctx context.Context, chatID, messageID string) (func(), error) {
-	// Get emoji list from config
-	emojiList := c.config.RandomReactionEmoji
-	var chosenEmoji string
-	if len(emojiList) == 0 {
-		// Default to "Pin" if no config
-		chosenEmoji = "Pin"
-	} else {
-		idx := rand.Intn(len(emojiList))
-		chosenEmoji = emojiList[idx]
-	}
-
-	req := larkim.NewCreateMessageReactionReqBuilder().
-		MessageId(messageID).
-		Body(larkim.NewCreateMessageReactionReqBodyBuilder().
-			ReactionType(larkim.NewEmojiBuilder().EmojiType(chosenEmoji).Build()).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.MessageReaction.Create(ctx, req)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to add reaction", map[string]any{
-			"emoji":      chosenEmoji,
-			"message_id": messageID,
-			"error":      err.Error(),
-		})
-		return func() {}, fmt.Errorf("feishu react: %w", err)
-	}
-	if !resp.Success() {
-		logger.ErrorCF("feishu", "Reaction API error", map[string]any{
-			"emoji":      chosenEmoji,
-			"message_id": messageID,
-			"code":       resp.Code,
-			"msg":        resp.Msg,
-		})
-		return func() {}, fmt.Errorf("feishu react api error (code=%d msg=%s)", resp.Code, resp.Msg)
-	}
-
-	var reactionID string
-	if resp.Data != nil && resp.Data.ReactionId != nil {
-		reactionID = *resp.Data.ReactionId
-	}
-	if reactionID == "" {
-		return func() {}, nil
-	}
-
-	var undone atomic.Bool
-	undo := func() {
-		if !undone.CompareAndSwap(false, true) {
-			return
-		}
-		delReq := larkim.NewDeleteMessageReactionReqBuilder().
-			MessageId(messageID).
-			ReactionId(reactionID).
-			Build()
-		_, _ = c.client.Im.V1.MessageReaction.Delete(context.Background(), delReq)
-	}
-	return undo, nil
-}
-
-// SendMedia implements channels.MediaSender.
-// Uploads images/files via Feishu API then sends as messages.
-func (c *FeishuChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
-	if !c.IsRunning() {
-		return channels.ErrNotRunning
-	}
-
-	if msg.ChatID == "" {
-		return fmt.Errorf("chat ID is empty: %w", channels.ErrSendFailed)
-	}
-
-	store := c.GetMediaStore()
-	if store == nil {
-		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
-	}
-
-	for _, part := range msg.Parts {
-		if err := c.sendMediaPart(ctx, msg.ChatID, part, store); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// sendMediaPart resolves and sends a single media part.
-func (c *FeishuChannel) sendMediaPart(
-	ctx context.Context,
-	chatID string,
-	part bus.MediaPart,
-	store media.MediaStore,
-) error {
-	localPath, err := store.Resolve(part.Ref)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to resolve media ref", map[string]any{
-			"ref":   part.Ref,
-			"error": err.Error(),
-		})
-		return nil // skip this part
-	}
-
-	file, err := os.Open(localPath)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to open media file", map[string]any{
-			"path":  localPath,
-			"error": err.Error(),
-		})
-		return nil // skip this part
-	}
-	defer file.Close()
-
-	switch part.Type {
-	case "image":
-		err = c.sendImage(ctx, chatID, file)
-	default:
-		filename := part.Filename
-		if filename == "" {
-			filename = "file"
-		}
-		err = c.sendFile(ctx, chatID, file, filename, part.Type)
-	}
-
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to send media", map[string]any{
-			"type":  part.Type,
-			"error": err.Error(),
-		})
-		return fmt.Errorf("feishu send media: %w", channels.ErrTemporary)
-	}
-	return nil
-}
-
-// --- Inbound message handling ---
-
-func (c *FeishuChannel) handleMessageReceive(ctx context.Context, event *larkim.P2MessageReceiveV1) error {
-	if event == nil || event.Event == nil || event.Event.Message == nil {
-		return nil
-	}
-
-	message := event.Event.Message
-	sender := event.Event.Sender
-
-	chatID := stringValue(message.ChatId)
-	if chatID == "" {
-		return nil
-	}
-
-	senderID := extractFeishuSenderID(sender)
-	if senderID == "" {
-		senderID = "unknown"
-	}
-
-	messageType := stringValue(message.MessageType)
-	messageID := stringValue(message.MessageId)
-	rawContent := stringValue(message.Content)
-
-	// Check allowlist early to avoid downloading media for rejected senders.
-	// BaseChannel.HandleMessage will check again, but this avoids wasted network I/O.
-	senderInfo := bus.SenderInfo{
-		Platform:    "feishu",
-		PlatformID:  senderID,
-		CanonicalID: identity.BuildCanonicalID("feishu", senderID),
-	}
-	if !c.IsAllowedSender(senderInfo) {
-		return nil
-	}
-
-	// Extract content based on message type
-	content := extractContent(messageType, rawContent)
-
-	// Handle media messages (download and store)
-	var mediaRefs []string
-	if store := c.GetMediaStore(); store != nil && messageID != "" {
-		mediaRefs = c.downloadInboundMedia(ctx, chatID, messageID, messageType, rawContent, store)
-	}
-
-	// Append media tags to content (like Telegram does)
-	content = appendMediaTags(content, messageType, mediaRefs)
-
-	if content == "" {
-		content = "[empty message]"
-	}
-
-	metadata := map[string]string{}
-	if messageID != "" {
-		metadata["message_id"] = messageID
-	}
-	if messageType != "" {
-		metadata["message_type"] = messageType
-	}
-	chatType := stringValue(message.ChatType)
-	if chatType != "" {
-		metadata["chat_type"] = chatType
-	}
-	if sender != nil && sender.TenantKey != nil {
-		metadata["tenant_key"] = *sender.TenantKey
-	}
-
-	var peer bus.Peer
-	if chatType == "p2p" {
-		peer = bus.Peer{Kind: "direct", ID: senderID}
-	} else {
-		peer = bus.Peer{Kind: "group", ID: chatID}
-
-		// Check if bot was mentioned
-		isMentioned := c.isBotMentioned(message)
-
-		// Strip mention placeholders from content before group trigger check
-		if len(message.Mentions) > 0 {
-			content = stripMentionPlaceholders(content, message.Mentions)
-		}
-
-		// In group chats, apply unified group trigger filtering
-		respond, cleaned := c.ShouldRespondInGroup(isMentioned, content)
-		if !respond {
-			return nil
-		}
-		content = cleaned
-	}
-
-	logger.InfoCF("feishu", "Feishu message received", map[string]any{
-		"sender_id":  senderID,
-		"chat_id":    chatID,
-		"message_id": messageID,
-		"preview":    utils.Truncate(content, 80),
-	})
-
-	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, mediaRefs, metadata, senderInfo)
-	return nil
-}
-
-// --- Internal helpers ---
-
-// fetchBotOpenID calls the Feishu bot info API to retrieve and store the bot's open_id.
-func (c *FeishuChannel) fetchBotOpenID(ctx context.Context) error {
-	resp, err := c.client.Do(ctx, &larkcore.ApiReq{
-		HttpMethod:                http.MethodGet,
-		ApiPath:                   "/open-apis/bot/v3/info",
-		SupportedAccessTokenTypes: []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant},
-	})
-	if err != nil {
-		return fmt.Errorf("bot info request: %w", err)
-	}
-
-	var result struct {
-		Code int `json:"code"`
-		Bot  struct {
-			OpenID string `json:"open_id"`
-		} `json:"bot"`
-	}
-	if err := json.Unmarshal(resp.RawBody, &result); err != nil {
-		return fmt.Errorf("bot info parse: %w", err)
-	}
-	if result.Code != 0 {
-		return fmt.Errorf("bot info api error (code=%d)", result.Code)
-	}
-	if result.Bot.OpenID == "" {
-		return fmt.Errorf("bot info: empty open_id")
-	}
-
-	c.botOpenID.Store(result.Bot.OpenID)
-	logger.InfoCF("feishu", "Fetched bot open_id from API", map[string]any{
-		"open_id": result.Bot.OpenID,
-	})
-	return nil
-}
-
-// isBotMentioned checks if the bot was @mentioned in the message.
-func (c *FeishuChannel) isBotMentioned(message *larkim.EventMessage) bool {
-	if message.Mentions == nil {
-		return false
-	}
-
-	knownID, _ := c.botOpenID.Load().(string)
-	if knownID == "" {
-		logger.DebugCF("feishu", "Bot open_id unknown, cannot detect @mention", nil)
-		return false
-	}
-
-	for _, m := range message.Mentions {
-		if m.Id == nil {
-			continue
-		}
-		if m.Id.OpenId != nil && *m.Id.OpenId == knownID {
-			return true
-		}
-	}
-	return false
-}
-
-// extractContent extracts text content from different message types.
-func extractContent(messageType, rawContent string) string {
-	if rawContent == "" {
-		return ""
-	}
-
-	switch messageType {
-	case larkim.MsgTypeText:
-		var textPayload struct {
-			Text string `json:"text"`
-		}
-		if err := json.Unmarshal([]byte(rawContent), &textPayload); err == nil {
-			return textPayload.Text
-		}
-		return rawContent
-
-	case larkim.MsgTypePost:
-		// Pass raw JSON to LLM — structured rich text is more informative than flattened plain text
-		return rawContent
-
-	case larkim.MsgTypeImage:
-		// Image messages don't have text content
-		return ""
-
-	case larkim.MsgTypeFile, larkim.MsgTypeAudio, larkim.MsgTypeMedia:
-		// File/audio/video messages may have a filename
-		name := extractFileName(rawContent)
-		if name != "" {
-			return name
-		}
-		return ""
-
-	default:
-		return rawContent
-	}
-}
-
-// downloadInboundMedia downloads media from inbound messages and stores in MediaStore.
-func (c *FeishuChannel) downloadInboundMedia(
-	ctx context.Context,
-	chatID, messageID, messageType, rawContent string,
-	store media.MediaStore,
-) []string {
-	var refs []string
-	scope := channels.BuildMediaScope("feishu", chatID, messageID)
-
-	switch messageType {
-	case larkim.MsgTypeImage:
-		imageKey := extractImageKey(rawContent)
-		if imageKey == "" {
-			return nil
-		}
-		ref := c.downloadResource(ctx, messageID, imageKey, "image", ".jpg", store, scope)
-		if ref != "" {
-			refs = append(refs, ref)
-		}
-
-	case larkim.MsgTypeFile, larkim.MsgTypeAudio, larkim.MsgTypeMedia:
-		fileKey := extractFileKey(rawContent)
-		if fileKey == "" {
-			return nil
-		}
-		// Derive a fallback extension from the message type.
-		var ext string
-		switch messageType {
-		case larkim.MsgTypeAudio:
-			ext = ".ogg"
-		case larkim.MsgTypeMedia:
-			ext = ".mp4"
-		default:
-			ext = "" // generic file — rely on resp.FileName
-		}
-		ref := c.downloadResource(ctx, messageID, fileKey, "file", ext, store, scope)
-		if ref != "" {
-			refs = append(refs, ref)
-		}
-	}
-
-	return refs
-}
-
-// downloadResource downloads a message resource (image/file) from Feishu,
-// writes it to the project media directory, and stores the reference in MediaStore.
-// fallbackExt (e.g. ".jpg") is appended when the resolved filename has no extension.
-func (c *FeishuChannel) downloadResource(
-	ctx context.Context,
-	messageID, fileKey, resourceType, fallbackExt string,
-	store media.MediaStore,
-	scope string,
-) string {
-	req := larkim.NewGetMessageResourceReqBuilder().
-		MessageId(messageID).
-		FileKey(fileKey).
-		Type(resourceType).
-		Build()
-
-	resp, err := c.client.Im.V1.MessageResource.Get(ctx, req)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to download resource", map[string]any{
-			"message_id": messageID,
-			"file_key":   fileKey,
-			"error":      err.Error(),
-		})
-		return ""
-	}
-	if !resp.Success() {
-		logger.ErrorCF("feishu", "Resource download api error", map[string]any{
-			"code": resp.Code,
-			"msg":  resp.Msg,
-		})
-		return ""
-	}
-
-	if resp.File == nil {
-		return ""
-	}
-	// Safely close the underlying reader if it implements io.Closer (e.g. HTTP response body).
-	if closer, ok := resp.File.(io.Closer); ok {
-		defer closer.Close()
-	}
-
-	filename := resp.FileName
-	if filename == "" {
-		filename = fileKey
-	}
-	// If filename still has no extension, append the fallback (like Telegram's ext parameter).
-	if filepath.Ext(filename) == "" && fallbackExt != "" {
-		filename += fallbackExt
-	}
-
-	// Write to the shared picoclaw_media directory using a unique name to avoid collisions.
-	mediaDir := filepath.Join(os.TempDir(), "picoclaw_media")
-	if mkdirErr := os.MkdirAll(mediaDir, 0o700); mkdirErr != nil {
-		logger.ErrorCF("feishu", "Failed to create media directory", map[string]any{
-			"error": mkdirErr.Error(),
-		})
-		return ""
-	}
-	ext := filepath.Ext(filename)
-	localPath := filepath.Join(mediaDir, utils.SanitizeFilename(messageID+"-"+fileKey+ext))
-
-	out, err := os.Create(localPath)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to create local file for resource", map[string]any{
-			"error": err.Error(),
-		})
-		return ""
-	}
-
-	if _, copyErr := io.Copy(out, resp.File); copyErr != nil {
-		out.Close()
-		os.Remove(localPath)
-		logger.ErrorCF("feishu", "Failed to write resource to file", map[string]any{
-			"error": copyErr.Error(),
-		})
-		return ""
-	}
-	out.Close()
-
-	ref, err := store.Store(localPath, media.MediaMeta{
-		Filename: filename,
-		Source:   "feishu",
-	}, scope)
-	if err != nil {
-		logger.ErrorCF("feishu", "Failed to store downloaded resource", map[string]any{
-			"file_key": fileKey,
-			"error":    err.Error(),
-		})
-		os.Remove(localPath)
-		return ""
-	}
-
-	return ref
-}
-
-// appendMediaTags appends media type tags to content (like Telegram's "[image: photo]").
-func appendMediaTags(content, messageType string, mediaRefs []string) string {
-	if len(mediaRefs) == 0 {
-		return content
-	}
-
-	var tag string
-	switch messageType {
-	case larkim.MsgTypeImage:
-		tag = "[image: photo]"
-	case larkim.MsgTypeAudio:
-		tag = "[audio]"
-	case larkim.MsgTypeMedia:
-		tag = "[video]"
-	case larkim.MsgTypeFile:
-		tag = "[file]"
-	default:
-		tag = "[attachment]"
-	}
-
-	if content == "" {
-		return tag
-	}
-	return content + " " + tag
-}
-
-// sendCard sends an interactive card message to a chat.
-func (c *FeishuChannel) sendCard(ctx context.Context, chatID, cardContent string) error {
-	req := larkim.NewCreateMessageReqBuilder().
-		ReceiveIdType(larkim.ReceiveIdTypeChatId).
-		Body(larkim.NewCreateMessageReqBodyBuilder().
-			ReceiveId(chatID).
-			MsgType(larkim.MsgTypeInteractive).
-			Content(cardContent).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Create(ctx, req)
-	if err != nil {
-		return fmt.Errorf("feishu send card: %w", channels.ErrTemporary)
-	}
-
-	if !resp.Success() {
-		return fmt.Errorf("feishu api error (code=%d msg=%s): %w", resp.Code, resp.Msg, channels.ErrTemporary)
-	}
-
-	logger.DebugCF("feishu", "Feishu card message sent", map[string]any{
-		"chat_id": chatID,
-	})
-
-	return nil
-}
-
-// sendImage uploads an image and sends it as a message.
-func (c *FeishuChannel) sendImage(ctx context.Context, chatID string, file *os.File) error {
-	// Upload image to get image_key
-	uploadReq := larkim.NewCreateImageReqBuilder().
-		Body(larkim.NewCreateImageReqBodyBuilder().
-			ImageType("message").
-			Image(file).
-			Build()).
-		Build()
-
-	uploadResp, err := c.client.Im.V1.Image.Create(ctx, uploadReq)
-	if err != nil {
-		return fmt.Errorf("feishu image upload: %w", err)
-	}
-	if !uploadResp.Success() {
-		return fmt.Errorf("feishu image upload api error (code=%d msg=%s)", uploadResp.Code, uploadResp.Msg)
-	}
-	if uploadResp.Data == nil || uploadResp.Data.ImageKey == nil {
-		return fmt.Errorf("feishu image upload: no image_key returned")
-	}
-
-	imageKey := *uploadResp.Data.ImageKey
-
-	// Send image message
-	content, _ := json.Marshal(map[string]string{"image_key": imageKey})
-	req := larkim.NewCreateMessageReqBuilder().
-		ReceiveIdType(larkim.ReceiveIdTypeChatId).
-		Body(larkim.NewCreateMessageReqBodyBuilder().
-			ReceiveId(chatID).
-			MsgType(larkim.MsgTypeImage).
-			Content(string(content)).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Create(ctx, req)
-	if err != nil {
-		return fmt.Errorf("feishu image send: %w", err)
-	}
-	if !resp.Success() {
-		return fmt.Errorf("feishu image send api error (code=%d msg=%s)", resp.Code, resp.Msg)
-	}
-	return nil
-}
-
-// sendFile uploads a file and sends it as a message.
-func (c *FeishuChannel) sendFile(ctx context.Context, chatID string, file *os.File, filename, fileType string) error {
-	// Map part type to Feishu file type
-	feishuFileType := "stream"
-	switch fileType {
-	case "audio":
-		feishuFileType = "opus"
-	case "video":
-		feishuFileType = "mp4"
-	}
-
-	// Upload file to get file_key
-	uploadReq := larkim.NewCreateFileReqBuilder().
-		Body(larkim.NewCreateFileReqBodyBuilder().
-			FileType(feishuFileType).
-			FileName(filename).
-			File(file).
-			Build()).
-		Build()
-
-	uploadResp, err := c.client.Im.V1.File.Create(ctx, uploadReq)
-	if err != nil {
-		return fmt.Errorf("feishu file upload: %w", err)
-	}
-	if !uploadResp.Success() {
-		return fmt.Errorf("feishu file upload api error (code=%d msg=%s)", uploadResp.Code, uploadResp.Msg)
-	}
-	if uploadResp.Data == nil || uploadResp.Data.FileKey == nil {
-		return fmt.Errorf("feishu file upload: no file_key returned")
-	}
-
-	fileKey := *uploadResp.Data.FileKey
-
-	// Send file message
-	content, _ := json.Marshal(map[string]string{"file_key": fileKey})
-	req := larkim.NewCreateMessageReqBuilder().
-		ReceiveIdType(larkim.ReceiveIdTypeChatId).
-		Body(larkim.NewCreateMessageReqBodyBuilder().
-			ReceiveId(chatID).
-			MsgType(larkim.MsgTypeFile).
-			Content(string(content)).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Create(ctx, req)
-	if err != nil {
-		return fmt.Errorf("feishu file send: %w", err)
-	}
-	if !resp.Success() {
-		return fmt.Errorf("feishu file send api error (code=%d msg=%s)", resp.Code, resp.Msg)
-	}
-	return nil
-}
-
-func extractFeishuSenderID(sender *larkim.EventSender) string {
-	if sender == nil || sender.SenderId == nil {
-		return ""
-	}
-
-	if sender.SenderId.UserId != nil && *sender.SenderId.UserId != "" {
-		return *sender.SenderId.UserId
-	}
-	if sender.SenderId.OpenId != nil && *sender.SenderId.OpenId != "" {
-		return *sender.SenderId.OpenId
-	}
-	if sender.SenderId.UnionId != nil && *sender.SenderId.UnionId != "" {
-		return *sender.SenderId.UnionId
-	}
-
-	return ""
-}
--- a/pkg/channels/feishu/feishu_64_test.go
+++ b/pkg/channels/feishu/feishu_64_test.go
@ -1,256 +0,0 @@
-//go:build amd64 || arm64 || riscv64 || mips64 || ppc64
-
-package feishu
-
-import (
-	"testing"
-
-	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
-)
-
-func TestExtractContent(t *testing.T) {
-	tests := []struct {
-		name        string
-		messageType string
-		rawContent  string
-		want        string
-	}{
-		{
-			name:        "text message",
-			messageType: "text",
-			rawContent:  `{"text": "hello world"}`,
-			want:        "hello world",
-		},
-		{
-			name:        "text message invalid JSON",
-			messageType: "text",
-			rawContent:  `not json`,
-			want:        "not json",
-		},
-		{
-			name:        "post message returns raw JSON",
-			messageType: "post",
-			rawContent:  `{"title": "test post"}`,
-			want:        `{"title": "test post"}`,
-		},
-		{
-			name:        "image message returns empty",
-			messageType: "image",
-			rawContent:  `{"image_key": "img_xxx"}`,
-			want:        "",
-		},
-		{
-			name:        "file message with filename",
-			messageType: "file",
-			rawContent:  `{"file_key": "file_xxx", "file_name": "report.pdf"}`,
-			want:        "report.pdf",
-		},
-		{
-			name:        "file message without filename",
-			messageType: "file",
-			rawContent:  `{"file_key": "file_xxx"}`,
-			want:        "",
-		},
-		{
-			name:        "audio message with filename",
-			messageType: "audio",
-			rawContent:  `{"file_key": "file_xxx", "file_name": "recording.ogg"}`,
-			want:        "recording.ogg",
-		},
-		{
-			name:        "media message with filename",
-			messageType: "media",
-			rawContent:  `{"file_key": "file_xxx", "file_name": "video.mp4"}`,
-			want:        "video.mp4",
-		},
-		{
-			name:        "unknown message type returns raw",
-			messageType: "sticker",
-			rawContent:  `{"sticker_id": "sticker_xxx"}`,
-			want:        `{"sticker_id": "sticker_xxx"}`,
-		},
-		{
-			name:        "empty raw content",
-			messageType: "text",
-			rawContent:  "",
-			want:        "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractContent(tt.messageType, tt.rawContent)
-			if got != tt.want {
-				t.Errorf("extractContent(%q, %q) = %q, want %q", tt.messageType, tt.rawContent, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestAppendMediaTags(t *testing.T) {
-	tests := []struct {
-		name        string
-		content     string
-		messageType string
-		mediaRefs   []string
-		want        string
-	}{
-		{
-			name:        "no refs returns content unchanged",
-			content:     "hello",
-			messageType: "image",
-			mediaRefs:   nil,
-			want:        "hello",
-		},
-		{
-			name:        "empty refs returns content unchanged",
-			content:     "hello",
-			messageType: "image",
-			mediaRefs:   []string{},
-			want:        "hello",
-		},
-		{
-			name:        "image with content",
-			content:     "check this",
-			messageType: "image",
-			mediaRefs:   []string{"ref1"},
-			want:        "check this [image: photo]",
-		},
-		{
-			name:        "image empty content",
-			content:     "",
-			messageType: "image",
-			mediaRefs:   []string{"ref1"},
-			want:        "[image: photo]",
-		},
-		{
-			name:        "audio",
-			content:     "listen",
-			messageType: "audio",
-			mediaRefs:   []string{"ref1"},
-			want:        "listen [audio]",
-		},
-		{
-			name:        "media/video",
-			content:     "watch",
-			messageType: "media",
-			mediaRefs:   []string{"ref1"},
-			want:        "watch [video]",
-		},
-		{
-			name:        "file",
-			content:     "report.pdf",
-			messageType: "file",
-			mediaRefs:   []string{"ref1"},
-			want:        "report.pdf [file]",
-		},
-		{
-			name:        "unknown type",
-			content:     "something",
-			messageType: "sticker",
-			mediaRefs:   []string{"ref1"},
-			want:        "something [attachment]",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := appendMediaTags(tt.content, tt.messageType, tt.mediaRefs)
-			if got != tt.want {
-				t.Errorf(
-					"appendMediaTags(%q, %q, %v) = %q, want %q",
-					tt.content,
-					tt.messageType,
-					tt.mediaRefs,
-					got,
-					tt.want,
-				)
-			}
-		})
-	}
-}
-
-func TestExtractFeishuSenderID(t *testing.T) {
-	strPtr := func(s string) *string { return &s }
-
-	tests := []struct {
-		name   string
-		sender *larkim.EventSender
-		want   string
-	}{
-		{
-			name:   "nil sender",
-			sender: nil,
-			want:   "",
-		},
-		{
-			name:   "nil sender ID",
-			sender: &larkim.EventSender{SenderId: nil},
-			want:   "",
-		},
-		{
-			name: "userId preferred",
-			sender: &larkim.EventSender{
-				SenderId: &larkim.UserId{
-					UserId:  strPtr("u_abc123"),
-					OpenId:  strPtr("ou_def456"),
-					UnionId: strPtr("on_ghi789"),
-				},
-			},
-			want: "u_abc123",
-		},
-		{
-			name: "openId fallback",
-			sender: &larkim.EventSender{
-				SenderId: &larkim.UserId{
-					UserId:  strPtr(""),
-					OpenId:  strPtr("ou_def456"),
-					UnionId: strPtr("on_ghi789"),
-				},
-			},
-			want: "ou_def456",
-		},
-		{
-			name: "unionId fallback",
-			sender: &larkim.EventSender{
-				SenderId: &larkim.UserId{
-					UserId:  strPtr(""),
-					OpenId:  strPtr(""),
-					UnionId: strPtr("on_ghi789"),
-				},
-			},
-			want: "on_ghi789",
-		},
-		{
-			name: "all empty strings",
-			sender: &larkim.EventSender{
-				SenderId: &larkim.UserId{
-					UserId:  strPtr(""),
-					OpenId:  strPtr(""),
-					UnionId: strPtr(""),
-				},
-			},
-			want: "",
-		},
-		{
-			name: "nil userId pointer falls through",
-			sender: &larkim.EventSender{
-				SenderId: &larkim.UserId{
-					UserId:  nil,
-					OpenId:  strPtr("ou_def456"),
-					UnionId: nil,
-				},
-			},
-			want: "ou_def456",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractFeishuSenderID(tt.sender)
-			if got != tt.want {
-				t.Errorf("extractFeishuSenderID() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}
--- a/pkg/channels/feishu/init.go
+++ b/pkg/channels/feishu/init.go
@ -1,13 +0,0 @@
-package feishu
-
-import (
-	"jane/pkg/bus"
-	"jane/pkg/channels"
-	"jane/pkg/config"
-)
-
-func init() {
-	channels.RegisterFactory("feishu", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
-		return NewFeishuChannel(cfg.Channels.Feishu, b)
-	})
-}
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@ -248,10 +248,6 @@ func (m *Manager) initChannels() error {
 		}
 	}

-	if m.config.Channels.Feishu.Enabled {
-		m.initChannel("feishu", "Feishu")
-	}
-
 	if m.config.Channels.Discord.Enabled && m.config.Channels.Discord.Token != "" {
 		m.initChannel("discord", "Discord")
 	}
@ -335,6 +331,7 @@ func (m *Manager) SetupHTTPServer(addr string, healthServer *health.Server) {
 		Addr:              addr,
 		Handler:           m.mux,
 		ReadTimeout:       30 * time.Second,
+		ReadHeaderTimeout: 10 * time.Second,
 		WriteTimeout:      30 * time.Second,
 	}
 }
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@ -257,7 +257,6 @@ func (d *AgentDefaults) GetModelName() string {
 type ChannelsConfig struct {
 	WhatsApp   WhatsAppConfig   `json:"whatsapp"`
 	Telegram   TelegramConfig   `json:"telegram"`
-	Feishu     FeishuConfig     `json:"feishu"`
 	Discord    DiscordConfig    `json:"discord"`
 	MaixCam    MaixCamConfig    `json:"maixcam"`
 	QQ         QQConfig         `json:"qq"`
@ -308,19 +307,6 @@ type TelegramConfig struct {
 	ReasoningChannelID string              `json:"reasoning_channel_id"    env:"PICOCLAW_CHANNELS_TELEGRAM_REASONING_CHANNEL_ID"`
 }

-type FeishuConfig struct {
-	Enabled             bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_FEISHU_ENABLED"`
-	AppID               string              `json:"app_id"                  env:"PICOCLAW_CHANNELS_FEISHU_APP_ID"`
-	AppSecret           string              `json:"app_secret"              env:"PICOCLAW_CHANNELS_FEISHU_APP_SECRET"`
-	EncryptKey          string              `json:"encrypt_key"             env:"PICOCLAW_CHANNELS_FEISHU_ENCRYPT_KEY"`
-	VerificationToken   string              `json:"verification_token"      env:"PICOCLAW_CHANNELS_FEISHU_VERIFICATION_TOKEN"`
-	AllowFrom           FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_FEISHU_ALLOW_FROM"`
-	GroupTrigger        GroupTriggerConfig  `json:"group_trigger,omitempty"`
-	Placeholder         PlaceholderConfig   `json:"placeholder,omitempty"`
-	ReasoningChannelID  string              `json:"reasoning_channel_id"    env:"PICOCLAW_CHANNELS_FEISHU_REASONING_CHANNEL_ID"`
-	RandomReactionEmoji FlexibleStringSlice `json:"random_reaction_emoji"   env:"PICOCLAW_CHANNELS_FEISHU_RANDOM_REACTION_EMOJI"`
-}
-
 type DiscordConfig struct {
 	Enabled            bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_DISCORD_ENABLED"`
 	Token              string              `json:"token"                   env:"PICOCLAW_CHANNELS_DISCORD_TOKEN"`
--- a/pkg/config/config_test.go
+++ b/pkg/config/config_test.go
@ -181,8 +181,8 @@ func TestConfig_BackwardCompat_NoAgentsList(t *testing.T) {
 		t.Fatalf("unmarshal: %v", err)
 	}

-	if len(cfg.Agents.List) != 0 {
-		t.Errorf("agents.list should be empty for backward compat, got %d", len(cfg.Agents.List))
+	if len(cfg.Agents.List) != 1 {
+		t.Errorf("agents.list should have default clinician agent for backward compat, got %d", len(cfg.Agents.List))
 	}
 	if len(cfg.Bindings) != 0 {
 		t.Errorf("bindings should be empty, got %d", len(cfg.Bindings))
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@ -36,6 +36,13 @@ func DefaultConfig() *Config {
 				SummarizeMessageThreshold: 20,
 				SummarizeTokenPercent:     75,
 			},
+			List: []AgentConfig{
+				{
+					ID:        "the-clinician",
+					Name:      "Medical Persona",
+					Workspace: filepath.Join(homePath, "Obsidian_Vault", "Patients"),
+				},
+			},
 		},
 		Bindings: []AgentBinding{},
 		Session: SessionConfig{
@ -59,14 +66,6 @@ func DefaultConfig() *Config {
 					Text:    "Thinking... 💭",
 				},
 			},
-			Feishu: FeishuConfig{
-				Enabled:           false,
-				AppID:             "",
-				AppSecret:         "",
-				EncryptKey:        "",
-				VerificationToken: "",
-				AllowFrom:         FlexibleStringSlice{},
-			},
 			Discord: DiscordConfig{
 				Enabled:     false,
 				Token:       "",
--- a/pkg/health/server.go
+++ b/pkg/health/server.go
@ -47,6 +47,7 @@ func NewServer(host string, port int) *Server {
 		Addr:              addr,
 		Handler:           mux,
 		ReadTimeout:       5 * time.Second,
+		ReadHeaderTimeout: 3 * time.Second,
 		WriteTimeout:      5 * time.Second,
 	}

--- a/pkg/migrate/sources/openclaw/common.go
+++ b/pkg/migrate/sources/openclaw/common.go
@ -15,7 +15,6 @@ var migrateableDirs = []string{
 var supportedChannels = map[string]bool{
 	"whatsapp":  true,
 	"telegram":  true,
-	"feishu":    true,
 	"discord":   true,
 	"maixcam":   true,
 	"qq":        true,
--- a/pkg/migrate/sources/openclaw/openclaw_config.go
+++ b/pkg/migrate/sources/openclaw/openclaw_config.go
@ -123,7 +123,6 @@ type OpenClawChannels struct {
 	Teams       *OpenClawTeamsConfig       `json:"msteams"`
 	IRC         *OpenClawIrcConfig         `json:"irc"`
 	Mattermost  *OpenClawMattermostConfig  `json:"mattermost"`
-	Feishu      *OpenClawFeishuConfig      `json:"feishu"`
 	IMessage    *OpenClawIMessageConfig    `json:"imessage"`
 	BlueBubbles *OpenClawBlueBubblesConfig `json:"bluebubbles"`
 	QQ          *OpenClawQQConfig          `json:"qq"`
@ -223,17 +222,6 @@ type OpenClawMattermostConfig struct {
 	Enabled   *bool    `json:"enabled"`
 }

-type OpenClawFeishuConfig struct {
-	AppID             *string  `json:"appId"`
-	AppSecret         *string  `json:"appSecret"`
-	Domain            *string  `json:"domain"`
-	DmPolicy          *string  `json:"dmPolicy"`
-	Enabled           *bool    `json:"enabled"`
-	VerificationToken *string  `json:"verificationToken"`
-	EncryptKey        *string  `json:"encryptKey"`
-	AllowFrom         []string `json:"allowFrom"`
-}
-
 type OpenClawIMessageConfig struct {
 	CliPath   *string  `json:"cliPath"`
 	DbPath    *string  `json:"dbPath"`
@ -375,8 +363,6 @@ func (c *OpenClawConfig) IsChannelEnabled(name string) bool {
 		return c.Channels.Matrix == nil || c.Channels.Matrix.Enabled == nil || *c.Channels.Matrix.Enabled
 	case "whatsapp":
 		return c.Channels.WhatsApp == nil || c.Channels.WhatsApp.Enabled == nil || *c.Channels.WhatsApp.Enabled
-	case "feishu":
-		return c.Channels.Feishu == nil || c.Channels.Feishu.Enabled == nil || *c.Channels.Feishu.Enabled
 	default:
 		return false
 	}
@ -409,11 +395,6 @@ func GetChannelAllowFrom(ch any) []string {
 			return nil
 		}
 		return c.AllowFrom
-	case *OpenClawFeishuConfig:
-		if c == nil {
-			return nil
-		}
-		return c.AllowFrom
 	default:
 		return nil
 	}
@ -628,7 +609,6 @@ type PeerMatch struct {
 type ChannelsConfig struct {
 	WhatsApp WhatsAppConfig `json:"whatsapp"`
 	Telegram TelegramConfig `json:"telegram"`
-	Feishu   FeishuConfig   `json:"feishu"`
 	Discord  DiscordConfig  `json:"discord"`
 	MaixCam  MaixCamConfig  `json:"maixcam"`
 	QQ       QQConfig       `json:"qq"`
@ -651,15 +631,6 @@ type TelegramConfig struct {
 	AllowFrom []string `json:"allow_from"`
 }

-type FeishuConfig struct {
-	Enabled           bool     `json:"enabled"`
-	AppID             string   `json:"app_id"`
-	AppSecret         string   `json:"app_secret"`
-	EncryptKey        string   `json:"encrypt_key"`
-	VerificationToken string   `json:"verification_token"`
-	AllowFrom         []string `json:"allow_from"`
-}
-
 type DiscordConfig struct {
 	Enabled     bool     `json:"enabled"`
 	Token       string   `json:"token"`
@ -822,26 +793,6 @@ func (c *OpenClawConfig) convertChannels(warnings *[]string) ChannelsConfig {
 		}
 	}

-	if c.Channels.Feishu != nil {
-		enabled := c.Channels.Feishu.Enabled == nil || *c.Channels.Feishu.Enabled
-		channels.Feishu = FeishuConfig{
-			Enabled:   enabled,
-			AllowFrom: c.Channels.Feishu.AllowFrom,
-		}
-		if c.Channels.Feishu.AppID != nil {
-			channels.Feishu.AppID = *c.Channels.Feishu.AppID
-		}
-		if c.Channels.Feishu.AppSecret != nil {
-			channels.Feishu.AppSecret = *c.Channels.Feishu.AppSecret
-		}
-		if c.Channels.Feishu.EncryptKey != nil {
-			channels.Feishu.EncryptKey = *c.Channels.Feishu.EncryptKey
-		}
-		if c.Channels.Feishu.VerificationToken != nil {
-			channels.Feishu.VerificationToken = *c.Channels.Feishu.VerificationToken
-		}
-	}
-
 	if c.Channels.QQ != nil && supportedChannels["qq"] {
 		channels.QQ = QQConfig{
 			Enabled:   true,
@ -1021,13 +972,6 @@ func (c ChannelsConfig) ToStandardChannels() config.ChannelsConfig {
 			Token:   c.Telegram.Token,
 			Proxy:   c.Telegram.Proxy,
 		},
-		Feishu: config.FeishuConfig{
-			Enabled:           c.Feishu.Enabled,
-			AppID:             c.Feishu.AppID,
-			AppSecret:         c.Feishu.AppSecret,
-			EncryptKey:        c.Feishu.EncryptKey,
-			VerificationToken: c.Feishu.VerificationToken,
-		},
 		Discord: config.DiscordConfig{
 			Enabled:     c.Discord.Enabled,
 			Token:       c.Discord.Token,
--- a/pkg/migrate/sources/openclaw/openclaw_config_test.go
+++ b/pkg/migrate/sources/openclaw/openclaw_config_test.go
@ -198,12 +198,6 @@ func TestConvertToPicoClaw(t *testing.T) {
 				"enabled": true,
 				"bridgeUrl": "http://localhost:3000"
 			},
-			"feishu": {
-				"enabled": true,
-				"appId": "app-id",
-				"appSecret": "app-secret",
-				"allowFrom": ["user3"]
-			},
 			"signal": {
 				"enabled": true
 			}
@ -270,10 +264,6 @@ func TestConvertToPicoClaw(t *testing.T) {
 		t.Errorf("expected whatsapp bridge URL 'http://localhost:3000', got '%s'", picoCfg.Channels.WhatsApp.BridgeURL)
 	}

-	if picoCfg.Channels.Feishu.AppID != "app-id" {
-		t.Errorf("expected feishu app ID 'app-id', got '%s'", picoCfg.Channels.Feishu.AppID)
-	}
-
 	if len(picoCfg.ModelList) != 1 {
 		t.Errorf("expected 1 model config (no models.json provided), got %d", len(picoCfg.ModelList))
 	}
--- a/pkg/tools/send_file_test.go
+++ b/pkg/tools/send_file_test.go
@ -14,7 +14,7 @@ import (
 func TestSendFileTool_MissingPath(t *testing.T) {
 	store := media.NewFileMediaStore()
 	tool := NewSendFileTool("/tmp", false, 0, store)
-	tool.SetContext("feishu", "chat123")
+	tool.SetContext("telegram", "chat123")

 	result := tool.Execute(context.Background(), map[string]any{})
 	if !result.IsError {
@ -35,7 +35,7 @@ func TestSendFileTool_NoContext(t *testing.T) {

 func TestSendFileTool_NoMediaStore(t *testing.T) {
 	tool := NewSendFileTool("/tmp", false, 0, nil)
-	tool.SetContext("feishu", "chat123")
+	tool.SetContext("telegram", "chat123")

 	result := tool.Execute(context.Background(), map[string]any{"path": "/tmp/test.txt"})
 	if !result.IsError {
@ -46,7 +46,7 @@ func TestSendFileTool_NoMediaStore(t *testing.T) {
 func TestSendFileTool_Directory(t *testing.T) {
 	store := media.NewFileMediaStore()
 	tool := NewSendFileTool("/tmp", false, 0, store)
-	tool.SetContext("feishu", "chat123")
+	tool.SetContext("telegram", "chat123")

 	result := tool.Execute(context.Background(), map[string]any{"path": "/tmp"})
 	if !result.IsError {
@ -64,7 +64,7 @@ func TestSendFileTool_FileTooLarge(t *testing.T) {

 	store := media.NewFileMediaStore()
 	tool := NewSendFileTool(dir, false, 512, store) // 512 byte limit
-	tool.SetContext("feishu", "chat123")
+	tool.SetContext("telegram", "chat123")

 	result := tool.Execute(context.Background(), map[string]any{"path": testFile})
 	if !result.IsError {
@ -91,7 +91,7 @@ func TestSendFileTool_Success(t *testing.T) {

 	store := media.NewFileMediaStore()
 	tool := NewSendFileTool(dir, false, 0, store)
-	tool.SetContext("feishu", "chat123")
+	tool.SetContext("telegram", "chat123")

 	result := tool.Execute(context.Background(), map[string]any{"path": testFile})
 	if result.IsError {
--- a/web/backend/api/channels.go
+++ b/web/backend/api/channels.go
@ -15,7 +15,6 @@ var channelCatalog = []channelCatalogItem{
 	{Name: "telegram", ConfigKey: "telegram"},
 	{Name: "discord", ConfigKey: "discord"},
 	{Name: "slack", ConfigKey: "slack"},
-	{Name: "feishu", ConfigKey: "feishu"},
 	{Name: "dingtalk", ConfigKey: "dingtalk"},
 	{Name: "line", ConfigKey: "line"},
 	{Name: "qq", ConfigKey: "qq"},
--- a/web/backend/dist/.gitkeep
+++ b/web/backend/dist/.gitkeep
@ -1 +0,0 @@
-# Keep the embedded web backend dist directory in version control.
--- a/web/backend/main.go
+++ b/web/backend/main.go
@ -163,7 +163,16 @@ func main() {
 	}()

 	// Start the Server
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	server := &http.Server{
+		Addr:              addr,
+		Handler:           handler,
+		ReadTimeout:       10 * time.Second,
+		ReadHeaderTimeout: 5 * time.Second,
+		WriteTimeout:      30 * time.Second,
+		IdleTimeout:       120 * time.Second,
+	}
+
+	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 		log.Fatalf("Server failed to start: %v", err)
 	}
 }
--- a/web/frontend/src/components/channels/channel-config-page.tsx
+++ b/web/frontend/src/components/channels/channel-config-page.tsx
@ -13,7 +13,6 @@ import {
 } from "@/api/channels"
 import { getChannelDisplayName } from "@/components/channels/channel-display-name"
 import { DiscordForm } from "@/components/channels/channel-forms/discord-form"
-import { FeishuForm } from "@/components/channels/channel-forms/feishu-form"
 import { GenericForm } from "@/components/channels/channel-forms/generic-form"
 import { SlackForm } from "@/components/channels/channel-forms/slack-form"
 import { TelegramForm } from "@/components/channels/channel-forms/telegram-form"
@ -125,10 +124,6 @@ function isConfigured(
      return asString(config.token) !== ""
    case "slack":
      return asString(config.bot_token) !== ""
-    case "feishu":
-      return (
-        asString(config.app_id) !== "" && asString(config.app_secret) !== ""
-      )
    case "dingtalk":
      return (
        asString(config.client_id) !== "" &&
@ -171,8 +166,6 @@ function getRequiredFieldKeys(channelName: string): string[] {
      return ["token"]
    case "slack":
      return ["bot_token"]
-    case "feishu":
-      return ["app_id", "app_secret"]
    case "dingtalk":
      return ["client_id", "client_secret"]
    case "line":
@ -422,15 +415,6 @@ export function ChannelConfigPage({ channelName }: ChannelConfigPageProps) {
            fieldErrors={fieldErrors}
          />
        )
-      case "feishu":
-        return (
-          <FeishuForm
-            config={editConfig}
-            onChange={handleChange}
-            isEdit={isEdit}
-            fieldErrors={fieldErrors}
-          />
-        )
      default:
        return (
          <GenericForm
--- a/web/frontend/src/components/channels/channel-forms/feishu-form.tsx
+++ b/web/frontend/src/components/channels/channel-forms/feishu-form.tsx
@ -1,121 +0,0 @@
-import { useTranslation } from "react-i18next"
-
-import type { ChannelConfig } from "@/api/channels"
-import { maskedSecretPlaceholder } from "@/components/secret-placeholder"
-import { Field, KeyInput } from "@/components/shared-form"
-import { Input } from "@/components/ui/input"
-
-interface FeishuFormProps {
-  config: ChannelConfig
-  onChange: (key: string, value: unknown) => void
-  isEdit: boolean
-  fieldErrors?: Record<string, string>
-}
-
-function asString(value: unknown): string {
-  return typeof value === "string" ? value : ""
-}
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return []
-  return value.filter((item): item is string => typeof item === "string")
-}
-
-export function FeishuForm({
-  config,
-  onChange,
-  isEdit,
-  fieldErrors = {},
-}: FeishuFormProps) {
-  const { t } = useTranslation()
-  const appSecretExtraHint =
-    isEdit && asString(config.app_secret)
-      ? ` ${t("channels.field.secretHintSet")}`
-      : ""
-  const verificationExtraHint =
-    isEdit && asString(config.verification_token)
-      ? ` ${t("channels.field.secretHintSet")}`
-      : ""
-  const encryptExtraHint =
-    isEdit && asString(config.encrypt_key)
-      ? ` ${t("channels.field.secretHintSet")}`
-      : ""
-
-  return (
-    <div className="space-y-5">
-      <Field
-        label={t("channels.field.appId")}
-        required
-        hint={t("channels.form.desc.appId")}
-        error={fieldErrors.app_id}
-      >
-        <Input
-          value={asString(config.app_id)}
-          onChange={(e) => onChange("app_id", e.target.value)}
-          placeholder="cli_xxxx"
-        />
-      </Field>
-
-      <Field
-        label={t("channels.field.appSecret")}
-        required
-        hint={`${t("channels.form.desc.appSecret")}${appSecretExtraHint}`}
-        error={fieldErrors.app_secret}
-      >
-        <KeyInput
-          value={asString(config._app_secret)}
-          onChange={(v) => onChange("_app_secret", v)}
-          placeholder={maskedSecretPlaceholder(
-            config.app_secret,
-            t("channels.field.secretPlaceholder"),
-          )}
-        />
-      </Field>
-
-      <Field
-        label={t("channels.field.verificationToken")}
-        hint={`${t("channels.form.desc.verificationToken")}${verificationExtraHint}`}
-      >
-        <KeyInput
-          value={asString(config._verification_token)}
-          onChange={(v) => onChange("_verification_token", v)}
-          placeholder={maskedSecretPlaceholder(
-            config.verification_token,
-            t("channels.field.secretPlaceholder"),
-          )}
-        />
-      </Field>
-      <Field
-        label={t("channels.field.encryptKey")}
-        hint={`${t("channels.form.desc.encryptKey")}${encryptExtraHint}`}
-      >
-        <KeyInput
-          value={asString(config._encrypt_key)}
-          onChange={(v) => onChange("_encrypt_key", v)}
-          placeholder={maskedSecretPlaceholder(
-            config.encrypt_key,
-            t("channels.field.secretPlaceholder"),
-          )}
-        />
-      </Field>
-      <Field
-        label={t("channels.field.allowFrom")}
-        hint={t("channels.form.desc.allowFrom")}
-      >
-        <Input
-          value={asStringArray(config.allow_from).join(", ")}
-          onChange={(e) =>
-            onChange(
-              "allow_from",
-              e.target.value
-                .split(",")
-                .map((s: string) => s.trim())
-                .filter(Boolean),
-            )
-          }
-          placeholder={t("channels.field.allowFromPlaceholder")}
-        />
-      </Field>
-    </div>
-  )
-}
--- a/web/frontend/src/hooks/use-sidebar-channels.ts
+++ b/web/frontend/src/hooks/use-sidebar-channels.ts
@ -30,7 +30,6 @@ import { gatewayAtom } from "@/store/gateway"
 const DEFAULT_VISIBLE_CHANNELS = 4
 const CHANNEL_IMPORTANCE_ORDER = [
  "discord",
-  "feishu",
  "telegram",
  "slack",
  "line",
@ -48,19 +47,6 @@ const CHANNEL_IMPORTANCE_INDEX = new Map(
  CHANNEL_IMPORTANCE_ORDER.map((name, index) => [name, index]),
 )

-function IconLark({ className }: { className?: string }) {
-  return React.createElement("span", {
-    className,
-    "aria-hidden": "true",
-    style: {
-      display: "inline-block",
-      backgroundColor: "currentColor",
-      mask: "url(/lark.svg) center / contain no-repeat",
-      WebkitMask: "url(/lark.svg) center / contain no-repeat",
-    } as React.CSSProperties,
-  })
-}
-
 const CHANNEL_ICON_MAP: Record<
  string,
  React.ComponentType<{ className?: string }>
@ -68,7 +54,6 @@ const CHANNEL_ICON_MAP: Record<
  telegram: IconBrandTelegram,
  discord: IconBrandDiscord,
  slack: IconBrandSlack,
-  feishu: IconLark,
  dingtalk: IconBrandDingtalk,
  line: IconBrandLine,
  qq: IconBrandQq,
--- a/web/frontend/src/i18n/locales/en.json
+++ b/web/frontend/src/i18n/locales/en.json
@ -223,7 +223,6 @@
      "telegram": "Telegram",
      "discord": "Discord",
      "slack": "Slack",
-      "feishu": "Feishu",
      "dingtalk": "DingTalk",
      "line": "LINE",
      "qq": "QQ",
--- a/web/frontend/src/i18n/locales/zh.json
+++ b/web/frontend/src/i18n/locales/zh.json
@ -223,7 +223,6 @@
      "telegram": "Telegram",
      "discord": "Discord",
      "slack": "Slack",
-      "feishu": "飞书",
      "dingtalk": "钉钉",
      "line": "LINE",
      "qq": "QQ",
--- a/workspace/IDENTITY.md
+++ b/workspace/IDENTITY.md
@ -17,7 +17,7 @@ Ultra-lightweight personal AI assistant written in Go, inspired by nanobot.
 - Web search and content fetching
 - File system operations (read, write, edit)
 - Shell command execution
- Multi-channel messaging (Telegram, WhatsApp, Feishu)
+- Multi-channel messaging (Telegram, WhatsApp, Discord)
 - Skill-based extensibility
 - Memory and context management
				`@ -1 +0,0 @@`
				`# Keep the embedded web backend dist directory in version control.`