From 676bd6d222509591614db840c2d36e94b2fdc3a2 Mon Sep 17 00:00:00 2001
From: PixelTux <pixeltux@proton.me>
Date: Thu, 19 Feb 2026 15:52:46 +0100
Subject: [PATCH 01/52] extra_hosts mapping to have enables container-to-host
 connectivity

---
 docker-compose.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docker-compose.yml b/docker-compose.yml
index 32e8ee339..c268b01cd 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -10,6 +10,9 @@ services:
     container_name: picoclaw-agent
     profiles:
       - agent
+    # Uncomment to access host network; leave commented unless needed.
+    #extra_hosts:
+    #  - "host.docker.internal:host-gateway"
     volumes:
       - ./config/config.json:/home/picoclaw/.picoclaw/config.json:ro
       - picoclaw-workspace:/home/picoclaw/.picoclaw/workspace
@@ -29,6 +32,9 @@ services:
     restart: unless-stopped
     profiles:
       - gateway
+    # Uncomment to access host network; leave commented unless needed.
+    #extra_hosts:
+    #  - "host.docker.internal:host-gateway"
     volumes:
       # Configuration file
       - ./config/config.json:/home/picoclaw/.picoclaw/config.json:ro

From 02b4d9fbe2dea85fb032ceba7d4c64f1499ba95a Mon Sep 17 00:00:00 2001
From: Artem Yadelskyi <mymmrac@gmail.com>
Date: Fri, 20 Feb 2026 22:35:16 +0200
Subject: [PATCH 02/52] feat(linter): Fix govet linter

---
 .github/workflows/pr.yml               | 19 -------------------
 .golangci.yaml                         |  1 -
 cmd/picoclaw/cmd_auth.go               |  6 +++---
 cmd/picoclaw/cmd_gateway.go            |  3 ++-
 cmd/picoclaw/cmd_skills.go             |  4 ++--
 pkg/channels/telegram.go               |  4 ++--
 pkg/channels/wecom.go                  |  2 +-
 pkg/channels/wecom_app.go              |  2 +-
 pkg/channels/wecom_app_test.go         | 13 -------------
 pkg/channels/wecom_test.go             |  4 +---
 pkg/migrate/migrate.go                 |  2 +-
 pkg/migrate/migrate_test.go            | 10 +++++-----
 pkg/providers/codex_cli_credentials.go |  2 +-
 pkg/tools/edit.go                      |  2 +-
 pkg/tools/filesystem.go                |  8 +++++---
 pkg/tools/i2c_linux.go                 |  2 +-
 pkg/voice/transcriber.go               |  6 +++---
 17 files changed, 29 insertions(+), 61 deletions(-)

diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 27782ced2..be1c10c52 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -24,25 +24,6 @@ jobs:
         with:
           version: v2.10.1
 
-  # TODO: Remove once linter is properly configured
-  vet:
-    name: Vet
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-
-      - name: Run go generate
-        run: go generate ./...
-
-      - name: Run go vet
-        run: go vet ./...
-
   test:
     name: Tests
     runs-on: ubuntu-latest
diff --git a/.golangci.yaml b/.golangci.yaml
index 6dafb6b56..d45d69e67 100644
--- a/.golangci.yaml
+++ b/.golangci.yaml
@@ -47,7 +47,6 @@ linters:
     - godox
     - goprintffuncname
     - gosec
-    - govet
     - ineffassign
     - lll
     - maintidx
diff --git a/cmd/picoclaw/cmd_auth.go b/cmd/picoclaw/cmd_auth.go
index 5bed7f116..729c56177 100644
--- a/cmd/picoclaw/cmd_auth.go
+++ b/cmd/picoclaw/cmd_auth.go
@@ -114,7 +114,7 @@ func authLoginOpenAI(useDeviceCode bool) {
 		os.Exit(1)
 	}
 
-	if err := auth.SetCredential("openai", cred); err != nil {
+	if err = auth.SetCredential("openai", cred); err != nil {
 		fmt.Printf("Failed to save credentials: %v\n", err)
 		os.Exit(1)
 	}
@@ -188,7 +188,7 @@ func authLoginGoogleAntigravity() {
 		fmt.Printf("Project: %s\n", projectID)
 	}
 
-	if err := auth.SetCredential("google-antigravity", cred); err != nil {
+	if err = auth.SetCredential("google-antigravity", cred); err != nil {
 		fmt.Printf("Failed to save credentials: %v\n", err)
 		os.Exit(1)
 	}
@@ -265,7 +265,7 @@ func authLoginPasteToken(provider string) {
 		os.Exit(1)
 	}
 
-	if err := auth.SetCredential(provider, cred); err != nil {
+	if err = auth.SetCredential(provider, cred); err != nil {
 		fmt.Printf("Failed to save credentials: %v\n", err)
 		os.Exit(1)
 	}
diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 00ec0f96d..9a3b6aa19 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -98,7 +98,8 @@ func gatewayCmd() {
 			channel, chatID = "cli", "direct"
 		}
 		// Use ProcessHeartbeat - no session history, each heartbeat is independent
-		response, err := agentLoop.ProcessHeartbeat(context.Background(), prompt, channel, chatID)
+		var response string
+		response, err = agentLoop.ProcessHeartbeat(context.Background(), prompt, channel, chatID)
 		if err != nil {
 			return tools.ErrorResult(fmt.Sprintf("Heartbeat error: %v", err))
 		}
diff --git a/cmd/picoclaw/cmd_skills.go b/cmd/picoclaw/cmd_skills.go
index 2dd46756a..0814494b3 100644
--- a/cmd/picoclaw/cmd_skills.go
+++ b/cmd/picoclaw/cmd_skills.go
@@ -118,7 +118,7 @@ func skillsInstallFromRegistry(cfg *config.Config, registryName, slug string) {
 	workspace := cfg.WorkspacePath()
 	targetDir := filepath.Join(workspace, "skills", slug)
 
-	if _, err := os.Stat(targetDir); err == nil {
+	if _, err = os.Stat(targetDir); err == nil {
 		fmt.Printf("\u2717 Skill '%s' already installed at %s\n", slug, targetDir)
 		os.Exit(1)
 	}
@@ -126,7 +126,7 @@ func skillsInstallFromRegistry(cfg *config.Config, registryName, slug string) {
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
 	defer cancel()
 
-	if err := os.MkdirAll(filepath.Join(workspace, "skills"), 0o755); err != nil {
+	if err = os.MkdirAll(filepath.Join(workspace, "skills"), 0o755); err != nil {
 		fmt.Printf("\u2717 Failed to create skills directory: %v\n", err)
 		os.Exit(1)
 	}
diff --git a/pkg/channels/telegram.go b/pkg/channels/telegram.go
index 2a971e147..a0a1c8d0a 100644
--- a/pkg/channels/telegram.go
+++ b/pkg/channels/telegram.go
@@ -267,10 +267,10 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 
 			transcribedText := ""
 			if c.transcriber != nil && c.transcriber.IsAvailable() {
-				ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+				transcriberCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
 				defer cancel()
 
-				result, err := c.transcriber.Transcribe(ctx, voicePath)
+				result, err := c.transcriber.Transcribe(transcriberCtx, voicePath)
 				if err != nil {
 					logger.ErrorCF("telegram", "Voice transcription failed", map[string]any{
 						"error": err.Error(),
diff --git a/pkg/channels/wecom.go b/pkg/channels/wecom.go
index 07bd8488c..f8daf89de 100644
--- a/pkg/channels/wecom.go
+++ b/pkg/channels/wecom.go
@@ -272,7 +272,7 @@ func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.Resp
 		AgentID    string   `xml:"AgentID"`
 	}
 
-	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
+	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
 		logger.ErrorCF("wecom", "Failed to parse XML", map[string]any{
 			"error": err.Error(),
 		})
diff --git a/pkg/channels/wecom_app.go b/pkg/channels/wecom_app.go
index 878504106..715c48707 100644
--- a/pkg/channels/wecom_app.go
+++ b/pkg/channels/wecom_app.go
@@ -348,7 +348,7 @@ func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.Resp
 		AgentID    string   `xml:"AgentID"`
 	}
 
-	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
+	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
 		logger.ErrorCF("wecom_app", "Failed to parse XML", map[string]any{
 			"error": err.Error(),
 		})
diff --git a/pkg/channels/wecom_app_test.go b/pkg/channels/wecom_app_test.go
index 6778520f3..abf15c52b 100644
--- a/pkg/channels/wecom_app_test.go
+++ b/pkg/channels/wecom_app_test.go
@@ -852,19 +852,6 @@ func TestWeComAppMessageStructures(t *testing.T) {
 		}
 	})
 
-	t.Run("WeComImageMessage structure", func(t *testing.T) {
-		msg := WeComImageMessage{
-			ToUser:  "user123",
-			MsgType: "image",
-			AgentID: 1000002,
-		}
-		msg.Image.MediaID = "media_123456"
-
-		if msg.Image.MediaID != "media_123456" {
-			t.Errorf("Image.MediaID = %q, want %q", msg.Image.MediaID, "media_123456")
-		}
-	})
-
 	t.Run("WeComAccessTokenResponse structure", func(t *testing.T) {
 		jsonData := `{
 			"errcode": 0,
diff --git a/pkg/channels/wecom_test.go b/pkg/channels/wecom_test.go
index 53cde2693..8afa7e8c3 100644
--- a/pkg/channels/wecom_test.go
+++ b/pkg/channels/wecom_test.go
@@ -198,10 +198,8 @@ func TestWeComBotVerifySignature(t *testing.T) {
 			Token:      "",
 			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
 		}
-		base := NewBaseChannel("wecom", cfgEmpty, msgBus, cfgEmpty.AllowFrom)
 		chEmpty := &WeComBotChannel{
-			BaseChannel: base,
-			config:      cfgEmpty,
+			config: cfgEmpty,
 		}
 
 		if !WeComVerifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
diff --git a/pkg/migrate/migrate.go b/pkg/migrate/migrate.go
index ab2635890..cfa82b7d7 100644
--- a/pkg/migrate/migrate.go
+++ b/pkg/migrate/migrate.go
@@ -67,7 +67,7 @@ func Run(opts Options) (*Result, error) {
 		return nil, err
 	}
 
-	if _, err := os.Stat(openclawHome); os.IsNotExist(err) {
+	if _, err = os.Stat(openclawHome); os.IsNotExist(err) {
 		return nil, fmt.Errorf("OpenClaw installation not found at %s", openclawHome)
 	}
 
diff --git a/pkg/migrate/migrate_test.go b/pkg/migrate/migrate_test.go
index ccc00f72c..b6b3d70aa 100644
--- a/pkg/migrate/migrate_test.go
+++ b/pkg/migrate/migrate_test.go
@@ -58,10 +58,10 @@ func TestConvertKeysToSnake(t *testing.T) {
 		t.Fatal("expected map[string]interface{}")
 	}
 
-	if _, ok := m["api_key"]; !ok {
+	if _, ok = m["api_key"]; !ok {
 		t.Error("expected key 'api_key' after conversion")
 	}
-	if _, ok := m["api_base"]; !ok {
+	if _, ok = m["api_base"]; !ok {
 		t.Error("expected key 'api_base' after conversion")
 	}
 
@@ -69,10 +69,10 @@ func TestConvertKeysToSnake(t *testing.T) {
 	if !ok {
 		t.Fatal("expected nested map")
 	}
-	if _, ok := nested["max_tokens"]; !ok {
+	if _, ok = nested["max_tokens"]; !ok {
 		t.Error("expected key 'max_tokens' in nested map")
 	}
-	if _, ok := nested["allow_from"]; !ok {
+	if _, ok = nested["allow_from"]; !ok {
 		t.Error("expected key 'allow_from' in nested map")
 	}
 
@@ -108,7 +108,7 @@ func TestLoadOpenClawConfig(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(configPath, data, 0o644); err != nil {
+	if err = os.WriteFile(configPath, data, 0o644); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/pkg/providers/codex_cli_credentials.go b/pkg/providers/codex_cli_credentials.go
index 46ba24b12..40f3ee2a1 100644
--- a/pkg/providers/codex_cli_credentials.go
+++ b/pkg/providers/codex_cli_credentials.go
@@ -31,7 +31,7 @@ func ReadCodexCliCredentials() (accessToken, accountID string, expiresAt time.Ti
 	}
 
 	var auth CodexCliAuth
-	if err := json.Unmarshal(data, &auth); err != nil {
+	if err = json.Unmarshal(data, &auth); err != nil {
 		return "", "", time.Time{}, fmt.Errorf("parsing %s: %w", authPath, err)
 	}
 
diff --git a/pkg/tools/edit.go b/pkg/tools/edit.go
index 39d2642d4..c28ca6ca2 100644
--- a/pkg/tools/edit.go
+++ b/pkg/tools/edit.go
@@ -72,7 +72,7 @@ func (t *EditFileTool) Execute(ctx context.Context, args map[string]any) *ToolRe
 		return ErrorResult(err.Error())
 	}
 
-	if _, err := os.Stat(resolvedPath); os.IsNotExist(err) {
+	if _, err = os.Stat(resolvedPath); os.IsNotExist(err) {
 		return ErrorResult(fmt.Sprintf("file not found: %s", path))
 	}
 
diff --git a/pkg/tools/filesystem.go b/pkg/tools/filesystem.go
index dd996bc0d..1bf50906e 100644
--- a/pkg/tools/filesystem.go
+++ b/pkg/tools/filesystem.go
@@ -34,17 +34,19 @@ func validatePath(path, workspace string, restrict bool) (string, error) {
 			return "", fmt.Errorf("access denied: path is outside the workspace")
 		}
 
+		var resolved string
 		workspaceReal := absWorkspace
-		if resolved, err := filepath.EvalSymlinks(absWorkspace); err == nil {
+		if resolved, err = filepath.EvalSymlinks(absWorkspace); err == nil {
 			workspaceReal = resolved
 		}
 
-		if resolved, err := filepath.EvalSymlinks(absPath); err == nil {
+		if resolved, err = filepath.EvalSymlinks(absPath); err == nil {
 			if !isWithinWorkspace(resolved, workspaceReal) {
 				return "", fmt.Errorf("access denied: symlink resolves outside workspace")
 			}
 		} else if os.IsNotExist(err) {
-			if parentResolved, err := resolveExistingAncestor(filepath.Dir(absPath)); err == nil {
+			var parentResolved string
+			if parentResolved, err = resolveExistingAncestor(filepath.Dir(absPath)); err == nil {
 				if !isWithinWorkspace(parentResolved, workspaceReal) {
 					return "", fmt.Errorf("access denied: symlink resolves outside workspace")
 				}
diff --git a/pkg/tools/i2c_linux.go b/pkg/tools/i2c_linux.go
index 2a0626340..4eaaf8f09 100644
--- a/pkg/tools/i2c_linux.go
+++ b/pkg/tools/i2c_linux.go
@@ -182,7 +182,7 @@ func (t *I2CTool) readDevice(args map[string]any) *ToolResult {
 		if reg < 0 || reg > 255 {
 			return ErrorResult("register must be between 0x00 and 0xFF")
 		}
-		_, err := syscall.Write(fd, []byte{byte(reg)})
+		_, err = syscall.Write(fd, []byte{byte(reg)})
 		if err != nil {
 			return ErrorResult(fmt.Sprintf("failed to write register 0x%02x: %v", reg, err))
 		}
diff --git a/pkg/voice/transcriber.go b/pkg/voice/transcriber.go
index ad8767d40..f973e77fe 100644
--- a/pkg/voice/transcriber.go
+++ b/pkg/voice/transcriber.go
@@ -79,17 +79,17 @@ func (t *GroqTranscriber) Transcribe(ctx context.Context, audioFilePath string)
 
 	logger.DebugCF("voice", "File copied to request", map[string]any{"bytes_copied": copied})
 
-	if err := writer.WriteField("model", "whisper-large-v3"); err != nil {
+	if err = writer.WriteField("model", "whisper-large-v3"); err != nil {
 		logger.ErrorCF("voice", "Failed to write model field", map[string]any{"error": err})
 		return nil, fmt.Errorf("failed to write model field: %w", err)
 	}
 
-	if err := writer.WriteField("response_format", "json"); err != nil {
+	if err = writer.WriteField("response_format", "json"); err != nil {
 		logger.ErrorCF("voice", "Failed to write response_format field", map[string]any{"error": err})
 		return nil, fmt.Errorf("failed to write response_format field: %w", err)
 	}
 
-	if err := writer.Close(); err != nil {
+	if err = writer.Close(); err != nil {
 		logger.ErrorCF("voice", "Failed to close multipart writer", map[string]any{"error": err})
 		return nil, fmt.Errorf("failed to close multipart writer: %w", err)
 	}

From 244eb0b47d0f694df4bdc96c316b23698eab7407 Mon Sep 17 00:00:00 2001
From: Goksu Ceylan <79890826+GoCeylan@users.noreply.github.com>
Date: Fri, 20 Feb 2026 19:15:46 -0500
Subject: [PATCH 03/52] fix (security): ExecTool `working_dir` sandbox escape
 (#478)

* fix (security) Shell working_dir bypass

* Feedback from @mengzhuo & Discord
- reuse internal security package to validate path
- add tests for workspace escape
---
 pkg/tools/shell.go      | 10 ++++++-
 pkg/tools/shell_test.go | 60 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/pkg/tools/shell.go b/pkg/tools/shell.go
index d2adb6468..a1ee0b6e1 100644
--- a/pkg/tools/shell.go
+++ b/pkg/tools/shell.go
@@ -144,7 +144,15 @@ func (t *ExecTool) Execute(ctx context.Context, args map[string]any) *ToolResult
 
 	cwd := t.workingDir
 	if wd, ok := args["working_dir"].(string); ok && wd != "" {
-		cwd = wd
+		if t.restrictToWorkspace && t.workingDir != "" {
+			resolvedWD, err := validatePath(wd, t.workingDir, true)
+			if err != nil {
+				return ErrorResult("Command blocked by safety guard (" + err.Error() + ")")
+			}
+			cwd = resolvedWD
+		} else {
+			cwd = wd
+		}
 	}
 
 	if cwd == "" {
diff --git a/pkg/tools/shell_test.go b/pkg/tools/shell_test.go
index f85b5a008..60f2b7b91 100644
--- a/pkg/tools/shell_test.go
+++ b/pkg/tools/shell_test.go
@@ -186,6 +186,66 @@ func TestShellTool_OutputTruncation(t *testing.T) {
 	}
 }
 
+// TestShellTool_WorkingDir_OutsideWorkspace verifies that working_dir cannot escape the workspace directly
+func TestShellTool_WorkingDir_OutsideWorkspace(t *testing.T) {
+	root := t.TempDir()
+	workspace := filepath.Join(root, "workspace")
+	outsideDir := filepath.Join(root, "outside")
+	if err := os.MkdirAll(workspace, 0755); err != nil {
+		t.Fatalf("failed to create workspace: %v", err)
+	}
+	if err := os.MkdirAll(outsideDir, 0755); err != nil {
+		t.Fatalf("failed to create outside dir: %v", err)
+	}
+
+	tool := NewExecTool(workspace, true)
+	result := tool.Execute(context.Background(), map[string]interface{}{
+		"command":     "pwd",
+		"working_dir": outsideDir,
+	})
+
+	if !result.IsError {
+		t.Fatalf("expected working_dir outside workspace to be blocked, got output: %s", result.ForLLM)
+	}
+	if !strings.Contains(result.ForLLM, "blocked") {
+		t.Errorf("expected 'blocked' in error, got: %s", result.ForLLM)
+	}
+}
+
+// TestShellTool_WorkingDir_SymlinkEscape verifies that a symlink inside the workspace
+// pointing outside cannot be used as working_dir to escape the sandbox.
+func TestShellTool_WorkingDir_SymlinkEscape(t *testing.T) {
+	root := t.TempDir()
+	workspace := filepath.Join(root, "workspace")
+	secretDir := filepath.Join(root, "secret")
+	if err := os.MkdirAll(workspace, 0755); err != nil {
+		t.Fatalf("failed to create workspace: %v", err)
+	}
+	if err := os.MkdirAll(secretDir, 0755); err != nil {
+		t.Fatalf("failed to create secret dir: %v", err)
+	}
+	os.WriteFile(filepath.Join(secretDir, "secret.txt"), []byte("top secret"), 0644)
+
+	// symlink lives inside the workspace but resolves to secretDir outside it
+	link := filepath.Join(workspace, "escape")
+	if err := os.Symlink(secretDir, link); err != nil {
+		t.Skipf("symlinks not supported in this environment: %v", err)
+	}
+
+	tool := NewExecTool(workspace, true)
+	result := tool.Execute(context.Background(), map[string]interface{}{
+		"command":     "cat secret.txt",
+		"working_dir": link,
+	})
+
+	if !result.IsError {
+		t.Fatalf("expected symlink working_dir escape to be blocked, got output: %s", result.ForLLM)
+	}
+	if !strings.Contains(result.ForLLM, "blocked") {
+		t.Errorf("expected 'blocked' in error, got: %s", result.ForLLM)
+	}
+}
+
 // TestShellTool_RestrictToWorkspace verifies workspace restriction
 func TestShellTool_RestrictToWorkspace(t *testing.T) {
 	tmpDir := t.TempDir()

From 80c8b5753338dc75286d93d8d62fa01654b1a2f0 Mon Sep 17 00:00:00 2001
From: Luke Milby <luke.milby@gmail.com>
Date: Fri, 20 Feb 2026 19:21:38 -0500
Subject: [PATCH 04/52] Fix Memory Write (#557)

* fix issue where memory will only trigger when asked to remember something

* updated prompt for memory usage
---
 pkg/agent/context.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/agent/context.go b/pkg/agent/context.go
index e989ffaaf..a9db5afdd 100644
--- a/pkg/agent/context.go
+++ b/pkg/agent/context.go
@@ -80,7 +80,7 @@ Your workspace is at: %s
 
 2. **Be helpful and accurate** - When using tools, briefly explain what you're doing.
 
-3. **Memory** - When remembering something, write to %s/memory/MEMORY.md`,
+3. **Memory** - When interacting with me if something seems memorable, update %s/memory/MEMORY.md`,
 		now, runtime, workspacePath, workspacePath, workspacePath, workspacePath, toolsSection, workspacePath)
 }
 

From 3df7f705408d5767e43a22975fd2d093f33b7705 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sat, 21 Feb 2026 16:05:39 +0800
Subject: [PATCH 05/52] fix: golangci-lint fmt

---
 pkg/tools/shell_test.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pkg/tools/shell_test.go b/pkg/tools/shell_test.go
index 60f2b7b91..d0a300c6c 100644
--- a/pkg/tools/shell_test.go
+++ b/pkg/tools/shell_test.go
@@ -191,10 +191,10 @@ func TestShellTool_WorkingDir_OutsideWorkspace(t *testing.T) {
 	root := t.TempDir()
 	workspace := filepath.Join(root, "workspace")
 	outsideDir := filepath.Join(root, "outside")
-	if err := os.MkdirAll(workspace, 0755); err != nil {
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
 		t.Fatalf("failed to create workspace: %v", err)
 	}
-	if err := os.MkdirAll(outsideDir, 0755); err != nil {
+	if err := os.MkdirAll(outsideDir, 0o755); err != nil {
 		t.Fatalf("failed to create outside dir: %v", err)
 	}
 
@@ -218,13 +218,13 @@ func TestShellTool_WorkingDir_SymlinkEscape(t *testing.T) {
 	root := t.TempDir()
 	workspace := filepath.Join(root, "workspace")
 	secretDir := filepath.Join(root, "secret")
-	if err := os.MkdirAll(workspace, 0755); err != nil {
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
 		t.Fatalf("failed to create workspace: %v", err)
 	}
-	if err := os.MkdirAll(secretDir, 0755); err != nil {
+	if err := os.MkdirAll(secretDir, 0o755); err != nil {
 		t.Fatalf("failed to create secret dir: %v", err)
 	}
-	os.WriteFile(filepath.Join(secretDir, "secret.txt"), []byte("top secret"), 0644)
+	os.WriteFile(filepath.Join(secretDir, "secret.txt"), []byte("top secret"), 0o644)
 
 	// symlink lives inside the workspace but resolves to secretDir outside it
 	link := filepath.Join(workspace, "escape")

From 00666022949fb993f9b07ae8c2bb844fde977b23 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sat, 21 Feb 2026 16:20:15 +0800
Subject: [PATCH 06/52] fix: golangci-lint run --fix

---
 pkg/tools/shell_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/tools/shell_test.go b/pkg/tools/shell_test.go
index d0a300c6c..6d35815e8 100644
--- a/pkg/tools/shell_test.go
+++ b/pkg/tools/shell_test.go
@@ -199,7 +199,7 @@ func TestShellTool_WorkingDir_OutsideWorkspace(t *testing.T) {
 	}
 
 	tool := NewExecTool(workspace, true)
-	result := tool.Execute(context.Background(), map[string]interface{}{
+	result := tool.Execute(context.Background(), map[string]any{
 		"command":     "pwd",
 		"working_dir": outsideDir,
 	})
@@ -233,7 +233,7 @@ func TestShellTool_WorkingDir_SymlinkEscape(t *testing.T) {
 	}
 
 	tool := NewExecTool(workspace, true)
-	result := tool.Execute(context.Background(), map[string]interface{}{
+	result := tool.Execute(context.Background(), map[string]any{
 		"command":     "cat secret.txt",
 		"working_dir": link,
 	})

From 023b245a285780edfcfbe90ae81b4c9cd7e7913d Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sat, 21 Feb 2026 15:33:35 +0800
Subject: [PATCH 07/52] docs: add Chinese channel documentation

---
 README.zh.md                               | 458 ++++++---------------
 docs/channels/dingtalk/README.zh.md        |  33 ++
 docs/channels/discord/README.zh.md         |  35 ++
 docs/channels/feishu/README.zh.md          |  37 ++
 docs/channels/line/README.zh.md            |  41 ++
 docs/channels/maixcam/README.zh.md         |  31 ++
 docs/channels/onebot/README.zh.md          |  31 ++
 docs/channels/qq/README.zh.md              |  32 ++
 docs/channels/slack/README.zh.md           |  33 ++
 docs/channels/telegram/README.zh.md        |  33 ++
 docs/channels/wecom/wecom_app/README.zh.md |  47 +++
 docs/channels/wecom/wecom_bot/README.zh.md |  41 ++
 12 files changed, 510 insertions(+), 342 deletions(-)
 create mode 100644 docs/channels/dingtalk/README.zh.md
 create mode 100644 docs/channels/discord/README.zh.md
 create mode 100644 docs/channels/feishu/README.zh.md
 create mode 100644 docs/channels/line/README.zh.md
 create mode 100644 docs/channels/maixcam/README.zh.md
 create mode 100644 docs/channels/onebot/README.zh.md
 create mode 100644 docs/channels/qq/README.zh.md
 create mode 100644 docs/channels/slack/README.zh.md
 create mode 100644 docs/channels/telegram/README.zh.md
 create mode 100644 docs/channels/wecom/wecom_app/README.zh.md
 create mode 100644 docs/channels/wecom/wecom_bot/README.zh.md

diff --git a/README.zh.md b/README.zh.md
index ab896b6c0..4d739c5eb 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -14,7 +14,8 @@
     <a href="https://x.com/SipeedIO"><img src="https://img.shields.io/badge/X_(Twitter)-SipeedIO-black?style=flat&logo=x&logoColor=white" alt="Twitter"></a>
   </p>
 
- **中文** | [日本語](README.ja.md) | [Português](README.pt-br.md) | [Tiếng Việt](README.vi.md) | [Français](README.fr.md) | [English](README.md)
+**中文** | [日本語](README.ja.md) | [Português](README.pt-br.md) | [Tiếng Việt](README.vi.md) | [Français](README.fr.md) | [English](README.md)
+
 </div>
 
 ---
@@ -42,14 +43,15 @@
 
 > [!CAUTION]
 > **🚨 SECURITY & OFFICIAL CHANNELS / 安全声明**
-> * **无加密货币 (NO CRYPTO):** PicoClaw **没有** 发行任何官方代币、Token 或虚拟货币。所有在 `pump.fun` 或其他交易平台上的相关声称均为 **诈骗**。
-> * **官方域名:** 唯一的官方网站是 **[picoclaw.io](https://picoclaw.io)**，公司官网是 **[sipeed.com](https://sipeed.com)**。
-> * **警惕:** 许多 `.ai/.org/.com/.net/...` 后缀的域名被第三方抢注，请勿轻信。
-> * **注意:** picoclaw正在初期的快速功能开发阶段，可能有尚未修复的网络安全问题，在1.0正式版发布前，请不要将其部署到生产环境中
-> * **注意:** picoclaw最近合并了大量PRs，近期版本可能内存占用较大(10~20MB)，我们将在功能较为收敛后进行资源占用优化.
-
+>
+> - **无加密货币 (NO CRYPTO):** PicoClaw **没有** 发行任何官方代币、Token 或虚拟货币。所有在 `pump.fun` 或其他交易平台上的相关声称均为 **诈骗**。
+> - **官方域名:** 唯一的官方网站是 **[picoclaw.io](https://picoclaw.io)**，公司官网是 **[sipeed.com](https://sipeed.com)**。
+> - **警惕:** 许多 `.ai/.org/.com/.net/...` 后缀的域名被第三方抢注，请勿轻信。
+> - **注意:** picoclaw正在初期的快速功能开发阶段，可能有尚未修复的网络安全问题，在1.0正式版发布前，请不要将其部署到生产环境中
+> - **注意:** picoclaw最近合并了大量PRs，近期版本可能内存占用较大(10~20MB)，我们将在功能较为收敛后进行资源占用优化.
 
 ## 📢 新闻 (News)
+
 2026-02-16 🎉 PicoClaw 在一周内突破了12K star! 感谢大家的关注！PicoClaw 的成长速度超乎我们预期. 由于PR数量的快速膨胀，我们亟需社区开发者参与维护. 我们需要的志愿者角色和roadmap已经发布到了[这里](docs/picoclaw_community_roadmap_260216.md), 期待你的参与！
 
 2026-02-13 🎉 **PicoClaw 在 4 天内突破 5000 Stars！** 感谢社区的支持！由于正值中国春节假期，PR 和 Issue 涌入较多，我们正在利用这段时间敲定 **项目路线图 (Roadmap)** 并组建 **开发者群组**，以便加速 PicoClaw 的开发。
@@ -69,12 +71,12 @@
 
 🤖 **AI 自举**: 纯 Go 语言原生实现 — 95% 的核心代码由 Agent 生成，并经由“人机回环 (Human-in-the-loop)”微调。
 
-|  | OpenClaw | NanoBot | **PicoClaw** |
-| --- | --- | --- | --- |
-| **语言** | TypeScript | Python | **Go** |
-| **RAM** | >1GB | >100MB | **< 10MB** |
-| **启动时间**</br>(0.8GHz core) | >500s | >30s | **<1s** |
-| **成本** | Mac Mini $599 | 大多数 Linux 开发板 ~$50 | **任意 Linux 开发板**</br>**低至 $10** |
+|                                | OpenClaw      | NanoBot                  | **PicoClaw**                           |
+| ------------------------------ | ------------- | ------------------------ | -------------------------------------- |
+| **语言**                       | TypeScript    | Python                   | **Go**                                 |
+| **RAM**                        | >1GB          | >100MB                   | **< 10MB**                             |
+| **启动时间**</br>(0.8GHz core) | >500s         | >30s                     | **<1s**                                |
+| **成本**                       | Mac Mini $599 | 大多数 Linux 开发板 ~$50 | **任意 Linux 开发板**</br>**低至 $10** |
 
 <img src="assets/compare.jpg" alt="PicoClaw" width="512">
 
@@ -101,9 +103,12 @@
 </table>
 
 ### 📱 在手机上轻松运行
+
 picoclaw 可以将你10年前的老旧手机废物利用，变身成为你的AI助理！快速指南:
+
 1. 先去应用商店下载安装Termux
 2. 打开后执行指令
+
 ```bash
 # 注意: 下面的v0.1.1 可以换为你实际看到的最新版本
 wget https://github.com/sipeed/picoclaw/releases/download/v0.1.1/picoclaw-linux-arm64
@@ -111,19 +116,17 @@ chmod +x picoclaw-linux-arm64
 pkg install proot
 termux-chroot ./picoclaw-linux-arm64 onboard
 ```
-然后跟随下面的“快速开始”章节继续配置picoclaw即可使用！   
+
+然后跟随下面的“快速开始”章节继续配置picoclaw即可使用！  
 <img src="assets/termux.jpg" alt="PicoClaw" width="512">
 
-
-
-
 ### 🐜 创新的低占用部署
 
 PicoClaw 几乎可以部署在任何 Linux 设备上！
 
-* $9.9 [LicheeRV-Nano](https://www.aliexpress.com/item/1005006519668532.html) E(网口) 或 W(WiFi6) 版本，用于极简家庭助手。
-* $30~50 [NanoKVM](https://www.aliexpress.com/item/1005007369816019.html)，或 $100 [NanoKVM-Pro](https://www.aliexpress.com/item/1005010048471263.html)，用于自动化服务器运维。
-* $50 [MaixCAM](https://www.aliexpress.com/item/1005008053333693.html) 或 $100 [MaixCAM2](https://www.kickstarter.com/projects/zepan/maixcam2-build-your-next-gen-4k-ai-camera)，用于智能监控。
+- $9.9 [LicheeRV-Nano](https://www.aliexpress.com/item/1005006519668532.html) E(网口) 或 W(WiFi6) 版本，用于极简家庭助手。
+- $30~50 [NanoKVM](https://www.aliexpress.com/item/1005007369816019.html)，或 $100 [NanoKVM-Pro](https://www.aliexpress.com/item/1005010048471263.html)，用于自动化服务器运维。
+- $50 [MaixCAM](https://www.aliexpress.com/item/1005008053333693.html) 或 $100 [MaixCAM2](https://www.kickstarter.com/projects/zepan/maixcam2-build-your-next-gen-4k-ai-camera)，用于智能监控。
 
 [https://private-user-images.githubusercontent.com/83055338/547056448-e7b031ff-d6f5-4468-bcca-5726b6fecb5c.mp4](https://private-user-images.githubusercontent.com/83055338/547056448-e7b031ff-d6f5-4468-bcca-5726b6fecb5c.mp4)
 
@@ -253,15 +256,14 @@ picoclaw onboard
     }
   }
 }
-
 ```
 
 > **新功能**: `model_list` 配置格式支持零代码添加 provider。详见[模型配置](#模型配置-model_list)章节。
 
 **3. 获取 API Key**
 
-* **LLM 提供商**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
-* **网络搜索** (可选): [Brave Search](https://brave.com/search/api) - 提供免费层级 (2000 请求/月)
+- **LLM 提供商**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
+- **网络搜索** (可选): [Brave Search](https://brave.com/search/api) - 提供免费层级 (2000 请求/月)
 
 > **注意**: 完整的配置模板请参考 `config.example.json`。
 
@@ -278,260 +280,28 @@ picoclaw agent -m "2+2 等于几？"
 
 ## 💬 聊天应用集成 (Chat Apps)
 
-通过 Telegram, Discord, 钉钉或企业微信与您的 PicoClaw 对话。
-
-| 渠道 | 设置难度 |
-| --- | --- |
-| **Telegram** | 简单 (仅需 token) |
-| **Discord** | 简单 (bot token + intents) |
-| **QQ** | 简单 (AppID + AppSecret) |
-| **钉钉 (DingTalk)** | 中等 (应用凭证) |
-| **企业微信 (WeCom)** | 中等 (企业ID + Webhook配置) |
-
-<details>
-<summary><b>Telegram</b> (推荐)</summary>
-
-**1. 创建机器人**
-
-* 打开 Telegram，搜索 `@BotFather`
-* 发送 `/newbot`，按照提示操作
-* 复制 token
-
-**2. 配置**
-
-```json
-{
-  "channels": {
-    "telegram": {
-      "enabled": true,
-      "token": "YOUR_BOT_TOKEN",
-      "allow_from": ["YOUR_USER_ID"]
-    }
-  }
-}
-
-```
-
-> 从 Telegram 上的 `@userinfobot` 获取您的用户 ID。
-
-**3. 运行**
-
-```bash
-picoclaw gateway
-
-```
-
-</details>
-
-<details>
-<summary><b>Discord</b></summary>
-
-**1. 创建机器人**
-
-* 前往 [https://discord.com/developers/applications](https://discord.com/developers/applications)
-* Create an application → Bot → Add Bot
-* 复制 bot token
-
-**2. 开启 Intents**
-
-* 在 Bot 设置中，开启 **MESSAGE CONTENT INTENT**
-* (可选) 如果计划基于成员数据使用白名单，开启 **SERVER MEMBERS INTENT**
-
-**3. 获取您的 User ID**
-
-* Discord 设置 → Advanced → 开启 **Developer Mode**
-* 右键点击您的头像 → **Copy User ID**
-
-**4. 配置**
-
-```json
-{
-  "channels": {
-    "discord": {
-      "enabled": true,
-      "token": "YOUR_BOT_TOKEN",
-      "allow_from": ["YOUR_USER_ID"],
-      "mention_only": false
-    }
-  }
-}
-
-```
-
-**5. 邀请机器人**
-
-* OAuth2 → URL Generator
-* Scopes: `bot`
-* Bot Permissions: `Send Messages`, `Read Message History`
-* 打开生成的邀请 URL，将机器人添加到您的服务器
-
-**6. 运行**
-
-```bash
-picoclaw gateway
-
-```
-
-</details>
-
-<details>
-<summary><b>QQ</b></summary>
-
-**1. 创建机器人**
-
-* 前往 [QQ 开放平台](https://q.qq.com/#)
-* 创建应用 → 获取 **AppID** 和 **AppSecret**
-
-**2. 配置**
-
-```json
-{
-  "channels": {
-    "qq": {
-      "enabled": true,
-      "app_id": "YOUR_APP_ID",
-      "app_secret": "YOUR_APP_SECRET",
-      "allow_from": []
-    }
-  }
-}
-
-```
-
-> 将 `allow_from` 设为空以允许所有用户，或指定 QQ 号以限制访问。
-
-**3. 运行**
-
-```bash
-picoclaw gateway
-
-```
-
-</details>
-
-<details>
-<summary><b>钉钉 (DingTalk)</b></summary>
-
-**1. 创建机器人**
-
-* 前往 [开放平台](https://open.dingtalk.com/)
-* 创建内部应用
-* 复制 Client ID 和 Client Secret
-
-**2. 配置**
-
-```json
-{
-  "channels": {
-    "dingtalk": {
-      "enabled": true,
-      "client_id": "YOUR_CLIENT_ID",
-      "client_secret": "YOUR_CLIENT_SECRET",
-      "allow_from": []
-    }
-  }
-}
-
-```
-
-> 将 `allow_from` 设为空以允许所有用户，或指定 ID 以限制访问。
-
-**3. 运行**
-
-```bash
-picoclaw gateway
-
-```
-
-</details>
-
-<details>
-<summary><b>企业微信 (WeCom)</b></summary>
-
-PicoClaw 支持两种企业微信集成方式：
-
-**选项1: 智能机器人 (WeCom Bot)** - 设置更简单，支持群聊
-**选项2: 自建应用 (WeCom App)** - 功能更丰富，支持主动推送消息
-
-详见 [企业微信自建应用配置指南](docs/wecom-app-configuration.md)。
-
-**快速设置 - 智能机器人：**
-
-**1. 创建机器人**
-
-* 前往企业微信管理后台 → 群聊 → 添加群机器人
-* 复制 Webhook URL (格式: `https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx`)
-
-**2. 配置**
-
-```json
-{
-  "channels": {
-    "wecom": {
-      "enabled": true,
-      "token": "YOUR_TOKEN",
-      "encoding_aes_key": "YOUR_ENCODING_AES_KEY",
-      "webhook_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY",
-      "webhook_host": "0.0.0.0",
-      "webhook_port": 18793,
-      "webhook_path": "/webhook/wecom",
-      "allow_from": []
-    }
-  }
-}
-```
-
-**快速设置 - 自建应用：**
-
-**1. 创建应用**
-
-* 前往企业微信管理后台 → 应用管理 → 创建应用
-* 复制 **AgentId** 和 **Secret**
-* 前往"我的企业"页面，复制 **CorpID**
-
-**2. 配置接收消息**
-
-* 在应用详情页，点击"接收消息" → "设置API"
-* 设置 URL 为 `http://your-server:18792/webhook/wecom-app`
-* 生成 **Token** 和 **EncodingAESKey**
-
-**3. 配置**
-
-```json
-{
-  "channels": {
-    "wecom_app": {
-      "enabled": true,
-      "corp_id": "wwxxxxxxxxxxxxxxxx",
-      "corp_secret": "YOUR_CORP_SECRET",
-      "agent_id": 1000002,
-      "token": "YOUR_TOKEN",
-      "encoding_aes_key": "YOUR_ENCODING_AES_KEY",
-      "webhook_host": "0.0.0.0",
-      "webhook_port": 18792,
-      "webhook_path": "/webhook/wecom-app",
-      "allow_from": []
-    }
-  }
-}
-```
-
-**4. 运行**
-
-```bash
-picoclaw gateway
-
-```
-
-> **注意**: 自建应用需要开放 18792 端口用于接收 Webhook 回调。生产环境建议使用反向代理配置 HTTPS。
-
-</details>
+PicoClaw 支持多种聊天平台，使您的 Agent 能够连接到任何地方。
+
+### 核心渠道
+
+| 渠道                 | 设置难度    | 特性说明                                  | 文档链接                                                                                                        |
+| -------------------- | ----------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| **Telegram**         | ⭐ 简单     | 推荐，支持语音转文字，长轮询无需公网      | [查看文档](docs/channels/telegram/README.zh.md)                                                                 |
+| **Discord**          | ⭐ 简单     | Socket Mode，支持群组/私信，Bot 生态成熟  | [查看文档](docs/channels/discord/README.zh.md)                                                                  |
+| **Slack**            | ⭐ 简单     | **Socket Mode** (无需公网 IP)，企业级支持 | [查看文档](docs/channels/slack/README.zh.md)                                                                    |
+| **QQ**               | ⭐⭐ 中等   | 官方机器人 API，适合国内社群              | [查看文档](docs/channels/qq/README.zh.md)                                                                       |
+| **钉钉 (DingTalk)**  | ⭐⭐ 中等   | Stream 模式无需公网，企业办公首选         | [查看文档](docs/channels/dingtalk/README.zh.md)                                                                 |
+| **企业微信 (WeCom)** | ⭐⭐⭐ 较难 | 支持群机器人(Webhook)和自建应用(API)      | [Bot 文档](docs/channels/wecom/wecom_bot/README.zh.md) / [App 文档](docs/channels/wecom/wecom_app/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)                                                                  |
 
 ## <img src="assets/clawdchat-icon.png" width="24" height="24" alt="ClawdChat"> 加入 Agent 社交网络
 
 只需通过 CLI 或任何集成的聊天应用发送一条消息，即可将 PicoClaw 连接到 Agent 社交网络。
 
-**阅读 `https://clawdchat.ai/skill.md` 并按照说明加入 [ClawdChat.ai](https://clawdchat.ai)
+\*\*阅读 `https://clawdchat.ai/skill.md` 并按照说明加入 [ClawdChat.ai](https://clawdchat.ai)
 
 ## ⚙️ 配置详解
 
@@ -567,7 +337,6 @@ PicoClaw 可以自动执行周期性任务。在工作区创建 `HEARTBEAT.md` 
 - Check my email for important messages
 - Review my calendar for upcoming events
 - Check the weather forecast
-
 ```
 
 Agent 将每隔 30 分钟（可配置）读取此文件，并使用可用工具执行任务。
@@ -580,22 +349,23 @@ Agent 将每隔 30 分钟（可配置）读取此文件，并使用可用工具
 # Periodic Tasks
 
 ## Quick Tasks (respond directly)
+
 - Report current time
 
 ## Long Tasks (use spawn for async)
+
 - Search the web for AI news and summarize
 - Check email and report important messages
-
 ```
 
 **关键行为：**
 
-| 特性 | 描述 |
-| --- | --- |
-| **spawn** | 创建异步子 Agent，不阻塞主心跳进程 |
-| **独立上下文** | 子 Agent 拥有独立上下文，无会话历史 |
+| 特性             | 描述                                     |
+| ---------------- | ---------------------------------------- |
+| **spawn**        | 创建异步子 Agent，不阻塞主心跳进程       |
+| **独立上下文**   | 子 Agent 拥有独立上下文，无会话历史      |
 | **message tool** | 子 Agent 通过 message 工具直接与用户通信 |
-| **非阻塞** | spawn 后，心跳继续处理下一个任务 |
+| **非阻塞**       | spawn 后，心跳继续处理下一个任务         |
 
 #### 子 Agent 通信原理
 
@@ -625,35 +395,34 @@ Agent 读取 HEARTBEAT.md
     "interval": 30
   }
 }
-
 ```
 
-| 选项 | 默认值 | 描述 |
-| --- | --- | --- |
-| `enabled` | `true` | 启用/禁用心跳 |
-| `interval` | `30` | 检查间隔，单位分钟 (最小: 5) |
+| 选项       | 默认值 | 描述                         |
+| ---------- | ------ | ---------------------------- |
+| `enabled`  | `true` | 启用/禁用心跳                |
+| `interval` | `30`   | 检查间隔，单位分钟 (最小: 5) |
 
 **环境变量:**
 
-* `PICOCLAW_HEARTBEAT_ENABLED=false` 禁用
-* `PICOCLAW_HEARTBEAT_INTERVAL=60` 更改间隔
+- `PICOCLAW_HEARTBEAT_ENABLED=false` 禁用
+- `PICOCLAW_HEARTBEAT_INTERVAL=60` 更改间隔
 
 ### 提供商 (Providers)
 
 > [!NOTE]
 > Groq 通过 Whisper 提供免费的语音转录。如果配置了 Groq，Telegram 语音消息将被自动转录为文字。
 
-| 提供商 | 用途 | 获取 API Key |
-| --- | --- | --- |
-| `gemini` | LLM (Gemini 直连) | [aistudio.google.com](https://aistudio.google.com) |
-| `zhipu` | LLM (智谱直连) | [bigmodel.cn](bigmodel.cn) |
-| `openrouter(待测试)` | LLM (推荐，可访问所有模型) | [openrouter.ai](https://openrouter.ai) |
-| `anthropic(待测试)` | LLM (Claude 直连) | [console.anthropic.com](https://console.anthropic.com) |
-| `openai(待测试)` | LLM (GPT 直连) | [platform.openai.com](https://platform.openai.com) |
-| `deepseek(待测试)` | LLM (DeepSeek 直连) | [platform.deepseek.com](https://platform.deepseek.com) |
-| `qwen` | LLM (通义千问) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
-| `groq` | LLM + **语音转录** (Whisper) | [console.groq.com](https://console.groq.com) |
-| `cerebras` | LLM (Cerebras 直连) | [cerebras.ai](https://cerebras.ai) |
+| 提供商               | 用途                         | 获取 API Key                                                         |
+| -------------------- | ---------------------------- | -------------------------------------------------------------------- |
+| `gemini`             | LLM (Gemini 直连)            | [aistudio.google.com](https://aistudio.google.com)                   |
+| `zhipu`              | LLM (智谱直连)               | [bigmodel.cn](bigmodel.cn)                                           |
+| `openrouter(待测试)` | LLM (推荐，可访问所有模型)   | [openrouter.ai](https://openrouter.ai)                               |
+| `anthropic(待测试)`  | LLM (Claude 直连)            | [console.anthropic.com](https://console.anthropic.com)               |
+| `openai(待测试)`     | LLM (GPT 直连)               | [platform.openai.com](https://platform.openai.com)                   |
+| `deepseek(待测试)`   | LLM (DeepSeek 直连)          | [platform.deepseek.com](https://platform.deepseek.com)               |
+| `qwen`               | LLM (通义千问)               | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
+| `groq`               | LLM + **语音转录** (Whisper) | [console.groq.com](https://console.groq.com)                         |
+| `cerebras`           | LLM (Cerebras 直连)          | [cerebras.ai](https://cerebras.ai)                                   |
 
 ### 模型配置 (model_list)
 
@@ -668,25 +437,25 @@ Agent 读取 HEARTBEAT.md
 
 #### 📋 所有支持的厂商
 
-| 厂商 | `model` 前缀 | 默认 API Base | 协议 | 获取 API Key |
-|------|-------------|---------------|------|--------------|
-| **OpenAI** | `openai/` | `https://api.openai.com/v1` | OpenAI | [获取密钥](https://platform.openai.com) |
-| **Anthropic** | `anthropic/` | `https://api.anthropic.com/v1` | Anthropic | [获取密钥](https://console.anthropic.com) |
-| **智谱 AI (GLM)** | `zhipu/` | `https://open.bigmodel.cn/api/paas/v4` | OpenAI | [获取密钥](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
-| **DeepSeek** | `deepseek/` | `https://api.deepseek.com/v1` | OpenAI | [获取密钥](https://platform.deepseek.com) |
-| **Google Gemini** | `gemini/` | `https://generativelanguage.googleapis.com/v1beta` | OpenAI | [获取密钥](https://aistudio.google.com/api-keys) |
-| **Groq** | `groq/` | `https://api.groq.com/openai/v1` | OpenAI | [获取密钥](https://console.groq.com) |
-| **Moonshot** | `moonshot/` | `https://api.moonshot.cn/v1` | OpenAI | [获取密钥](https://platform.moonshot.cn) |
-| **通义千问 (Qwen)** | `qwen/` | `https://dashscope.aliyuncs.com/compatible-mode/v1` | OpenAI | [获取密钥](https://dashscope.console.aliyun.com) |
-| **NVIDIA** | `nvidia/` | `https://integrate.api.nvidia.com/v1` | OpenAI | [获取密钥](https://build.nvidia.com) |
-| **Ollama** | `ollama/` | `http://localhost:11434/v1` | OpenAI | 本地（无需密钥） |
-| **OpenRouter** | `openrouter/` | `https://openrouter.ai/api/v1` | OpenAI | [获取密钥](https://openrouter.ai/keys) |
-| **VLLM** | `vllm/` | `http://localhost:8000/v1` | OpenAI | 本地 |
-| **Cerebras** | `cerebras/` | `https://api.cerebras.ai/v1` | OpenAI | [获取密钥](https://cerebras.ai) |
-| **火山引擎** | `volcengine/` | `https://ark.cn-beijing.volces.com/api/v3` | OpenAI | [获取密钥](https://console.volcengine.com) |
-| **神算云** | `shengsuanyun/` | `https://router.shengsuanyun.com/api/v1` | OpenAI | - |
-| **Antigravity** | `antigravity/` | Google Cloud | 自定义 | 仅 OAuth |
-| **GitHub Copilot** | `github-copilot/` | `localhost:4321` | gRPC | - |
+| 厂商                | `model` 前缀      | 默认 API Base                                       | 协议      | 获取 API Key                                                      |
+| ------------------- | ----------------- | --------------------------------------------------- | --------- | ----------------------------------------------------------------- |
+| **OpenAI**          | `openai/`         | `https://api.openai.com/v1`                         | OpenAI    | [获取密钥](https://platform.openai.com)                           |
+| **Anthropic**       | `anthropic/`      | `https://api.anthropic.com/v1`                      | Anthropic | [获取密钥](https://console.anthropic.com)                         |
+| **智谱 AI (GLM)**   | `zhipu/`          | `https://open.bigmodel.cn/api/paas/v4`              | OpenAI    | [获取密钥](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
+| **DeepSeek**        | `deepseek/`       | `https://api.deepseek.com/v1`                       | OpenAI    | [获取密钥](https://platform.deepseek.com)                         |
+| **Google Gemini**   | `gemini/`         | `https://generativelanguage.googleapis.com/v1beta`  | OpenAI    | [获取密钥](https://aistudio.google.com/api-keys)                  |
+| **Groq**            | `groq/`           | `https://api.groq.com/openai/v1`                    | OpenAI    | [获取密钥](https://console.groq.com)                              |
+| **Moonshot**        | `moonshot/`       | `https://api.moonshot.cn/v1`                        | OpenAI    | [获取密钥](https://platform.moonshot.cn)                          |
+| **通义千问 (Qwen)** | `qwen/`           | `https://dashscope.aliyuncs.com/compatible-mode/v1` | OpenAI    | [获取密钥](https://dashscope.console.aliyun.com)                  |
+| **NVIDIA**          | `nvidia/`         | `https://integrate.api.nvidia.com/v1`               | OpenAI    | [获取密钥](https://build.nvidia.com)                              |
+| **Ollama**          | `ollama/`         | `http://localhost:11434/v1`                         | OpenAI    | 本地（无需密钥）                                                  |
+| **OpenRouter**      | `openrouter/`     | `https://openrouter.ai/api/v1`                      | OpenAI    | [获取密钥](https://openrouter.ai/keys)                            |
+| **VLLM**            | `vllm/`           | `http://localhost:8000/v1`                          | OpenAI    | 本地                                                              |
+| **Cerebras**        | `cerebras/`       | `https://api.cerebras.ai/v1`                        | OpenAI    | [获取密钥](https://cerebras.ai)                                   |
+| **火山引擎**        | `volcengine/`     | `https://ark.cn-beijing.volces.com/api/v3`          | OpenAI    | [获取密钥](https://console.volcengine.com)                        |
+| **神算云**          | `shengsuanyun/`   | `https://router.shengsuanyun.com/api/v1`            | OpenAI    | -                                                                 |
+| **Antigravity**     | `antigravity/`    | Google Cloud                                        | 自定义    | 仅 OAuth                                                          |
+| **GitHub Copilot**  | `github-copilot/` | `localhost:4321`                                    | gRPC      | -                                                                 |
 
 #### 基础配置示例
 
@@ -720,6 +489,7 @@ Agent 读取 HEARTBEAT.md
 #### 各厂商配置示例
 
 **OpenAI**
+
 ```json
 {
   "model_name": "gpt-5.2",
@@ -729,6 +499,7 @@ Agent 读取 HEARTBEAT.md
 ```
 
 **智谱 AI (GLM)**
+
 ```json
 {
   "model_name": "glm-4.7",
@@ -738,6 +509,7 @@ Agent 读取 HEARTBEAT.md
 ```
 
 **DeepSeek**
+
 ```json
 {
   "model_name": "deepseek-chat",
@@ -747,6 +519,7 @@ Agent 读取 HEARTBEAT.md
 ```
 
 **Anthropic (使用 OAuth)**
+
 ```json
 {
   "model_name": "claude-sonnet-4.6",
@@ -754,9 +527,11 @@ Agent 读取 HEARTBEAT.md
   "auth_method": "oauth"
 }
 ```
+
 > 运行 `picoclaw auth login --provider anthropic` 来设置 OAuth 凭证。
 
 **Ollama (本地)**
+
 ```json
 {
   "model_name": "llama3",
@@ -765,6 +540,7 @@ Agent 读取 HEARTBEAT.md
 ```
 
 **自定义代理/API**
+
 ```json
 {
   "model_name": "my-custom-model",
@@ -802,6 +578,7 @@ Agent 读取 HEARTBEAT.md
 旧的 `providers` 配置格式**已弃用**，但为向后兼容仍支持。
 
 **旧配置（已弃用）：**
+
 ```json
 {
   "providers": {
@@ -820,6 +597,7 @@ Agent 读取 HEARTBEAT.md
 ```
 
 **新配置（推荐）：**
+
 ```json
 {
   "model_list": [
@@ -844,7 +622,7 @@ Agent 读取 HEARTBEAT.md
 
 **1. 获取 API key 和 base URL**
 
-* 获取 [API key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)
+- 获取 [API key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)
 
 **2. 配置**
 
@@ -866,7 +644,6 @@ Agent 读取 HEARTBEAT.md
     }
   }
 }
-
 ```
 
 **3. 运行**
@@ -946,30 +723,29 @@ picoclaw agent -m "你好"
     "interval": 30
   }
 }
-
 ```
 
 </details>
 
 ## CLI 命令行参考
 
-| 命令 | 描述 |
-| --- | --- |
-| `picoclaw onboard` | 初始化配置和工作区 |
-| `picoclaw agent -m "..."` | 与 Agent 对话 |
-| `picoclaw agent` | 交互式聊天模式 |
-| `picoclaw gateway` | 启动网关 (Gateway) |
-| `picoclaw status` | 显示状态 |
-| `picoclaw cron list` | 列出所有定时任务 |
-| `picoclaw cron add ...` | 添加定时任务 |
+| 命令                      | 描述               |
+| ------------------------- | ------------------ |
+| `picoclaw onboard`        | 初始化配置和工作区 |
+| `picoclaw agent -m "..."` | 与 Agent 对话      |
+| `picoclaw agent`          | 交互式聊天模式     |
+| `picoclaw gateway`        | 启动网关 (Gateway) |
+| `picoclaw status`         | 显示状态           |
+| `picoclaw cron list`      | 列出所有定时任务   |
+| `picoclaw cron add ...`   | 添加定时任务       |
 
 ### 定时任务 / 提醒 (Scheduled Tasks)
 
 PicoClaw 通过 `cron` 工具支持定时提醒和重复任务：
 
-* **一次性提醒**: "Remind me in 10 minutes" (10分钟后提醒我) → 10分钟后触发一次
-* **重复任务**: "Remind me every 2 hours" (每2小时提醒我) → 每2小时触发
-* **Cron 表达式**: "Remind me at 9am daily" (每天上午9点提醒我) → 使用 cron 表达式
+- **一次性提醒**: "Remind me in 10 minutes" (10分钟后提醒我) → 10分钟后触发一次
+- **重复任务**: "Remind me every 2 hours" (每2小时提醒我) → 每2小时触发
+- **Cron 表达式**: "Remind me at 9am daily" (每天上午9点提醒我) → 使用 cron 表达式
 
 任务存储在 `~/.picoclaw/workspace/cron/` 中并自动处理。
 
@@ -983,7 +759,7 @@ PicoClaw 通过 `cron` 工具支持定时提醒和重复任务：
 
 用户群组：
 
-Discord:  [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
+Discord: [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
 
 <img src="assets/wechat.png" alt="PicoClaw" width="512">
 
@@ -997,6 +773,7 @@ Discord:  [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
 
 1. 在 [https://brave.com/search/api](https://brave.com/search/api) 获取免费 API Key (每月 2000 次免费查询)
 2. 添加到 `~/.picoclaw/config.json`:
+
 ```json
 {
   "tools": {
@@ -1013,11 +790,8 @@ Discord:  [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
     }
   }
 }
-
 ```
 
-
-
 ### 遇到内容过滤错误 (Content Filtering Errors)
 
 某些提供商（如智谱）有严格的内容过滤。尝试改写您的问题或使用其他模型。
@@ -1030,10 +804,10 @@ Discord:  [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
 
 ## 📝 API Key 对比
 
-| 服务 | 免费层级 | 适用场景 |
-| --- | --- | --- |
-| **OpenRouter** | 200K tokens/月 | 多模型聚合 (Claude, GPT-4 等) |
-| **智谱 (Zhipu)** | 200K tokens/月 | 最适合中国用户 |
-| **Brave Search** | 2000 次查询/月 | 网络搜索功能 |
-| **Groq** | 提供免费层级 | 极速推理 (Llama, Mixtral) |
-| **Cerebras** | 提供免费层级 | 极速推理 (Llama, Qwen 等) |
\ No newline at end of file
+| 服务             | 免费层级       | 适用场景                      |
+| ---------------- | -------------- | ----------------------------- |
+| **OpenRouter**   | 200K tokens/月 | 多模型聚合 (Claude, GPT-4 等) |
+| **智谱 (Zhipu)** | 200K tokens/月 | 最适合中国用户                |
+| **Brave Search** | 2000 次查询/月 | 网络搜索功能                  |
+| **Groq**         | 提供免费层级   | 极速推理 (Llama, Mixtral)     |
+| **Cerebras**     | 提供免费层级   | 极速推理 (Llama, Qwen 等)     |
diff --git a/docs/channels/dingtalk/README.zh.md b/docs/channels/dingtalk/README.zh.md
new file mode 100644
index 000000000..1e445d0b0
--- /dev/null
+++ b/docs/channels/dingtalk/README.zh.md
@@ -0,0 +1,33 @@
+# 钉钉
+
+钉钉是阿里巴巴的企业通讯平台，在中国职场中广受欢迎。它采用流式 SDK 来维持持久连接。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "dingtalk": {
+      "enabled": true,
+      "client_id": "YOUR_CLIENT_ID",
+      "client_secret": "YOUR_CLIENT_SECRET",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段          | 类型   | 必填 | 描述                             |
+| ------------- | ------ | ---- | -------------------------------- |
+| enabled       | bool   | 是   | 是否启用钉钉频道                 |
+| client_id     | string | 是   | 钉钉应用的 Client ID             |
+| client_secret | string | 是   | 钉钉应用的 Client Secret         |
+| allow_from    | array  | 否   | 用户ID白名单，空表示允许所有用户 |
+
+## 设置流程
+
+1. 前往 [钉钉开放平台](https://open.dingtalk.com/)
+2. 创建一个企业内部应用
+3. 从应用设置中获取 Client ID 和 Client Secret
+4. 配置OAuth和事件订阅(如需要)
+5. 将 Client ID 和 Client Secret 填入配置文件中
diff --git a/docs/channels/discord/README.zh.md b/docs/channels/discord/README.zh.md
new file mode 100644
index 000000000..5b597eced
--- /dev/null
+++ b/docs/channels/discord/README.zh.md
@@ -0,0 +1,35 @@
+# Discord
+
+Discord 是一个专为社区设计的免费语音、视频和文本聊天应用。PicoClaw 通过 Discord Bot API 连接到 Discord 服务器，支持接收和发送消息。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "discord": {
+      "enabled": true,
+      "token": "YOUR_BOT_TOKEN",
+      "allow_from": ["YOUR_USER_ID"],
+      "mention_only": false
+    }
+  }
+}
+```
+
+| 字段         | 类型   | 必填 | 描述                             |
+| ------------ | ------ | ---- | -------------------------------- |
+| enabled      | bool   | 是   | 是否启用 Discord 频道            |
+| token        | string | 是   | Discord 机器人 Token             |
+| allow_from   | array  | 否   | 用户ID白名单，空表示允许所有用户 |
+| mention_only | bool   | 否   | 是否仅响应提及机器人的消息       |
+
+## 设置流程
+
+1. 前往 [Discord 开发者门户](https://discord.com/developers/applications) 创建一个新的应用
+2. 启用 Intents:
+   - Message Content Intent
+   - Server Members Intent
+3. 获取 Bot Token
+4. 将 Bot Token 填入配置文件中
+5. 邀请机器人加入服务器并授予必要权限(例如发送消息、读取消息历史等)
diff --git a/docs/channels/feishu/README.zh.md b/docs/channels/feishu/README.zh.md
new file mode 100644
index 000000000..310827723
--- /dev/null
+++ b/docs/channels/feishu/README.zh.md
@@ -0,0 +1,37 @@
+# 飞书
+
+飞书（国际版名称：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白名单，空表示允许所有用户 |
+
+## 设置流程
+
+1. 前往 [飞书开放平台](https://open.feishu.cn/)创建应用程序
+2. 获取 App ID 和 App Secret
+3. 配置事件订阅和Webhook URL
+4. 设置加密(可选,生产环境建议启用)
+5. 将 App ID、App Secret、Encrypt Key 和 Verification Token(如果启用加密) 填入配置文件中
diff --git a/docs/channels/line/README.zh.md b/docs/channels/line/README.zh.md
new file mode 100644
index 000000000..fd3aa80da
--- /dev/null
+++ b/docs/channels/line/README.zh.md
@@ -0,0 +1,41 @@
+# Line
+
+PicoClaw 通过 LINE Messaging API 配合 Webhook 回调功能实现对 LINE 的支持。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "line": {
+      "enabled": true,
+      "channel_secret": "YOUR_CHANNEL_SECRET",
+      "channel_access_token": "YOUR_CHANNEL_ACCESS_TOKEN",
+      "webhook_host": "0.0.0.0",
+      "webhook_port": 18791,
+      "webhook_path": "/webhook/line",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段                 | 类型   | 必填 | 描述                                       |
+| -------------------- | ------ | ---- | ------------------------------------------ |
+| enabled              | bool   | 是   | 是否启用 LINE Channel                      |
+| channel_secret       | string | 是   | LINE Messaging API 的 Channel Secret       |
+| channel_access_token | string | 是   | LINE Messaging API 的 Channel Access Token |
+| webhook_host         | string | 是   | Webhook 监听的主机地址 (通常为 0.0.0.0)    |
+| webhook_port         | int    | 是   | Webhook 监听的端口 (默认为 18791)          |
+| webhook_path         | string | 是   | Webhook 的路径 (默认为 /webhook/line)      |
+| allow_from           | array  | 否   | 用户ID白名单，空表示允许所有用户           |
+
+## 设置流程
+
+1. 前往 [LINE Developers Console](https://developers.line.biz/console/) 创建一个服务提供商和一个 Messaging API Channel
+2. 获取 Channel Secret 和 Channel Access Token
+3. 配置Webhook:
+   - Line要求Webhook必须使用HTTPS协议，因此需要部署一个支持HTTPS的服务器，或者使用反向代理工具如ngrok将本地服务器暴露到公网
+   - 将 Webhook URL 设置为 `https://your-domain.com/webhook/line`
+   - 启用 Webhook 并验证 URL
+4. 将 Channel Secret 和 Channel Access Token 填入配置文件中
diff --git a/docs/channels/maixcam/README.zh.md b/docs/channels/maixcam/README.zh.md
new file mode 100644
index 000000000..8d53d4bef
--- /dev/null
+++ b/docs/channels/maixcam/README.zh.md
@@ -0,0 +1,31 @@
+# MaixCam
+
+MaixCam 是专用于连接矽速科技 MaixCAM 与 MaixCAM2 AI 摄像设备的通道。它采用 TCP 套接字实现双向通信，支持边缘 AI 部署场景。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "maixcam": {
+      "enabled": true,
+      "server_address": "0.0.0.0:8899",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段           | 类型   | 必填 | 描述                             |
+| -------------- | ------ | ---- | -------------------------------- |
+| enabled        | bool   | 是   | 是否启用 MaixCam 频道            |
+| server_address | string | 是   | TCP 服务器监听地址和端口         |
+| allow_from     | array  | 否   | 设备ID白名单，空表示允许所有设备 |
+
+## 使用场景
+
+MaixCam 通道使 PicoClaw 能够作为边缘设备的 AI 后端运行：
+
+- **智能监控** ：MaixCAM 发送图像帧，PicoClaw 通过视觉模型进行分析
+- **物联网控制** ：设备发送传感器数据，PicoClaw 协调响应
+- **离线AI** ：在本地网络部署 PicoClaw 实现低延迟推理
diff --git a/docs/channels/onebot/README.zh.md b/docs/channels/onebot/README.zh.md
new file mode 100644
index 000000000..6195f1c98
--- /dev/null
+++ b/docs/channels/onebot/README.zh.md
@@ -0,0 +1,31 @@
+# OneBot
+
+OneBot 是一个面向 QQ 机器人的开放协议标准，为多种 QQ 机器人实现（例如 go-cqhttp、Mirai）提供了统一的接口。它使用 WebSocket 进行通信。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "onebot": {
+      "enabled": true,
+      "ws_url": "ws://localhost:8080",
+      "access_token": "",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段         | 类型   | 必填 | 描述                             |
+| ------------ | ------ | ---- | -------------------------------- |
+| enabled      | bool   | 是   | 是否启用 OneBot 频道             |
+| ws_url       | string | 是   | OneBot 服务器的 WebSocket URL    |
+| access_token | string | 否   | 连接 OneBot 服务器的访问令牌     |
+| allow_from   | array  | 否   | 用户ID白名单，空表示允许所有用户 |
+
+## 设置流程
+
+1. 部署一个 OneBot 兼容的实现(例如napcat)
+2. 配置 OneBot 实现以启用 WebSocket 服务并设置访问令牌(如果需要)
+3. 将 WebSocket URL 和访问令牌填入配置文件中
diff --git a/docs/channels/qq/README.zh.md b/docs/channels/qq/README.zh.md
new file mode 100644
index 000000000..bd774960f
--- /dev/null
+++ b/docs/channels/qq/README.zh.md
@@ -0,0 +1,32 @@
+# QQ
+
+PicoClaw 通过 QQ 开放平台的官方机器人 API 提供对 QQ 的支持。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "qq": {
+      "enabled": true,
+      "app_id": "YOUR_APP_ID",
+      "app_secret": "YOUR_APP_SECRET",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段       | 类型   | 必填 | 描述                             |
+| ---------- | ------ | ---- | -------------------------------- |
+| enabled    | bool   | 是   | 是否启用 QQ Channel              |
+| app_id     | string | 是   | QQ 机器人应用的 App ID           |
+| app_secret | string | 是   | QQ 机器人应用的 App Secret       |
+| allow_from | array  | 否   | 用户ID白名单，空表示允许所有用户 |
+
+## 设置流程
+
+1. 前往 [QQ 开放平台](https://q.qq.com/) 创建一个机器人
+2. 通过仪表盘获取 App ID 和 App Secret
+3. 开启机器人沙箱模式, 将用户和群添加到沙箱中
+4. 将 App ID 和 App Secret 填入配置文件中
diff --git a/docs/channels/slack/README.zh.md b/docs/channels/slack/README.zh.md
new file mode 100644
index 000000000..58ebcb566
--- /dev/null
+++ b/docs/channels/slack/README.zh.md
@@ -0,0 +1,33 @@
+# Slack
+
+Slack 是全球领先的企业级即时通讯平台。PicoClaw 采用 Slack 的 Socket Mode 实现实时双向通信，无需配置公开的 Webhook 端点。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "slack": {
+      "enabled": true,
+      "bot_token": "xoxb-...",
+      "app_token": "xapp-...",
+      "allow_from": []
+    }
+  }
+}
+```
+
+| 字段       | 类型   | 必填 | 描述                                                     |
+| ---------- | ------ | ---- | -------------------------------------------------------- |
+| enabled    | bool   | 是   | 是否启用 Slack 频道                                      |
+| bot_token  | string | 是   | Slack 机器人的 Bot User OAuth Token (以 xoxb- 开头)      |
+| app_token  | string | 是   | Slack 应用的 Socket Mode App Level Token (以 xapp- 开头) |
+| allow_from | array  | 否   | 用户ID白名单，空表示允许所有用户                         |
+
+## 设置流程
+
+1. 前往 [Slack API](https://api.slack.com/) 创建一个新的 Slack 应用
+2. 启用 Socket Mode 并获取 App Level Token
+3. 添加 Bot Token Scopes(例如`chat:write`、`im:history`等)
+4. 安装应用到工作区并获取 Bot User OAuth Token
+5. 将 Bot Token 和 App Token 填入配置文件中
diff --git a/docs/channels/telegram/README.zh.md b/docs/channels/telegram/README.zh.md
new file mode 100644
index 000000000..d453c68fa
--- /dev/null
+++ b/docs/channels/telegram/README.zh.md
@@ -0,0 +1,33 @@
+# Telegram
+
+Telegram Channel 通过 Telegram 机器人 API 使用长轮询实现基于机器人的通信。它支持文本消息、媒体附件（照片、语音、音频、文档）、通过 Groq Whisper 进行语音转录以及内置命令处理器。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "telegram": {
+      "enabled": true,
+      "token": "123456789:ABCdefGHIjklMNOpqrsTUVwxyz",
+      "allow_from": ["123456789"],
+      "proxy": ""
+    }
+  }
+}
+```
+
+| 字段       | 类型   | 必填 | 描述                                                      |
+| ---------- | ------ | ---- | --------------------------------------------------------- |
+| enabled    | bool   | 是   | 是否启用 Telegram 频道                                    |
+| token      | string | 是   | Telegram 机器人 API Token                                 |
+| allow_from | array  | 否   | 用户ID白名单，空表示允许所有用户                          |
+| proxy      | string | 否   | 连接 Telegram API 的代理 URL (例如 http://127.0.0.1:7890) |
+
+## 设置流程
+
+1. 在 Telegram 中搜索 `@BotFather`
+2. 发送 `/newbot` 命令并按照提示创建新机器人
+3. 获取 HTTP API Token
+4. 将 Token 填入配置文件中
+5. (可选) 配置 `allow_from` 以限制允许互动的用户 ID (可通过 `@userinfobot` 获取 ID)
diff --git a/docs/channels/wecom/wecom_app/README.zh.md b/docs/channels/wecom/wecom_app/README.zh.md
new file mode 100644
index 000000000..1e6a0e2b3
--- /dev/null
+++ b/docs/channels/wecom/wecom_app/README.zh.md
@@ -0,0 +1,47 @@
+# 企业微信自建应用
+
+企业微信自建应用是指企业在企业微信中创建的应用，主要用于企业内部使用。通过企业微信自建应用，企业可以实现与员工的高效沟通和协作，提高工作效率。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "wecom_app": {
+      "enabled": true,
+      "corp_id": "wwxxxxxxxxxxxxxxxx",
+      "corp_secret": "YOUR_CORP_SECRET",
+      "agent_id": 1000002,
+      "token": "YOUR_TOKEN",
+      "encoding_aes_key": "YOUR_ENCODING_AES_KEY",
+      "webhook_host": "0.0.0.0",
+      "webhook_port": 18792,
+      "webhook_path": "/webhook/wecom-app",
+      "allow_from": [],
+      "reply_timeout": 5
+    }
+  }
+}
+```
+
+| 字段             | 类型   | 必填 | 描述                                     |
+| ---------------- | ------ | ---- | ---------------------------------------- |
+| corp_id          | string | 是   | 企业 ID                                  |
+| corp_secret      | string | 是   | 应用程序密钥                             |
+| agent_id         | int    | 是   | 应用程序代理 ID                          |
+| token            | string | 是   | 回调验证令牌                             |
+| encoding_aes_key | string | 是   | 43 字符 AES 密钥                         |
+| webhook_host     | string | 否   | HTTP 服务器绑定地址                      |
+| webhook_port     | int    | 否   | HTTP 服务器端口（默认：18792）           |
+| webhook_path     | string | 否   | Webhook 路径（默认：/webhook/wecom-app） |
+| allow_from       | array  | 否   | 用户 ID 白名单                           |
+| reply_timeout    | int    | 否   | 回复超时时间（秒）                       |
+
+## 设置流程
+
+1. 登录 [企业微信管理后台](https://work.weixin.qq.com/)
+2. 进入“应用管理” -> “创建应用”
+3. 获取企业 ID (CorpID) 和应用 Secret
+4. 在应用设置中配置“接收消息”，获取 Token 和 EncodingAESKey
+5. 设置回调 URL 为 `http://<your-server-ip>:<port>/webhook/wecom-app`
+6. 将 CorpID, Secret, AgentID 等信息填入配置文件
diff --git a/docs/channels/wecom/wecom_bot/README.zh.md b/docs/channels/wecom/wecom_bot/README.zh.md
new file mode 100644
index 000000000..c4bb1c87e
--- /dev/null
+++ b/docs/channels/wecom/wecom_bot/README.zh.md
@@ -0,0 +1,41 @@
+# 企业微信机器人
+
+企业微信机器人是企业微信提供的一种快速接入方式，可以通过 Webhook URL 接收消息。
+
+## 配置
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "enabled": true,
+      "token": "YOUR_TOKEN",
+      "encoding_aes_key": "YOUR_ENCODING_AES_KEY",
+      "webhook_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY",
+      "webhook_host": "0.0.0.0",
+      "webhook_port": 18793,
+      "webhook_path": "/webhook/wecom",
+      "allow_from": [],
+      "reply_timeout": 5
+    }
+  }
+}
+```
+
+| 字段             | 类型   | 必填 | 描述                                         |
+| ---------------- | ------ | ---- | -------------------------------------------- |
+| token            | string | 是   | 签名验证代币                                 |
+| encoding_aes_key | string | 是   | 用于解密的 43 字符 AES 密钥                  |
+| webhook_url      | string | 是   | 用于发送回复的企业微信群聊机器人 Webhook URL |
+| webhook_host     | string | 否   | HTTP 服务器绑定地址（默认：0.0.0.0）         |
+| webhook_port     | int    | 否   | HTTP 服务器端口（默认：18793）               |
+| webhook_path     | string | 否   | Webhook 端点路径（默认：/webhook/wecom）     |
+| allow_from       | array  | 否   | 用户 ID 白名单（空值 = 允许所有用户）        |
+| reply_timeout    | int    | 否   | 回复超时时间（单位：秒，默认值：5）          |
+
+## 设置流程
+
+1. 在企业微信群中添加机器人
+2. 获取 Webhook URL
+3. (如需接收消息) 在机器人配置页面设置接收消息的 API 地址（回调地址）以及 Token 和 EncodingAESKey
+4. 将相关信息填入配置文件

From aea4f25c8387aee5e16b03a126beebbd712ff26d Mon Sep 17 00:00:00 2001
From: zepan <zepanwucai@gmail.com>
Date: Sat, 21 Feb 2026 22:45:47 +0800
Subject: [PATCH 08/52] 1. update wechat qrcode. 2. add CONTRIBUTING.md

---
 CONTRIBUTING.md    | 302 ++++++++++++++++++++++++++++++++++++++++++++
 CONTRIBUTING.zh.md | 303 +++++++++++++++++++++++++++++++++++++++++++++
 assets/wechat.png  | Bin 144319 -> 144045 bytes
 3 files changed, 605 insertions(+)
 create mode 100644 CONTRIBUTING.md
 create mode 100644 CONTRIBUTING.zh.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..88227f493
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,302 @@
+# Contributing to PicoClaw
+
+Thank you for your interest in contributing to PicoClaw! This project is a community-driven effort to build the lightweight and versatile personal AI assistant. We welcome contributions of all kinds: bug fixes, features, documentation, translations, and testing.
+
+PicoClaw itself was substantially developed with AI assistance — we embrace this approach and have built our contribution process around it.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Ways to Contribute](#ways-to-contribute)
+- [Getting Started](#getting-started)
+- [Development Setup](#development-setup)
+- [Making Changes](#making-changes)
+- [AI-Assisted Contributions](#ai-assisted-contributions)
+- [Pull Request Process](#pull-request-process)
+- [Branch Strategy](#branch-strategy)
+- [Code Review](#code-review)
+- [Communication](#communication)
+
+---
+
+## Code of Conduct
+
+We are committed to maintaining a welcoming and respectful community. Be kind, constructive, and assume good faith. Harassment or discrimination of any kind will not be tolerated.
+
+---
+
+## Ways to Contribute
+
+- **Bug reports** — Open an issue using the bug report template.
+- **Feature requests** — Open an issue using the feature request template; discuss before implementing.
+- **Code** — Fix bugs or implement features. See the workflow below.
+- **Documentation** — Improve READMEs, docs, inline comments, or translations.
+- **Testing** — Run PicoClaw on new hardware, channels, or LLM providers and report your results.
+
+For substantial new features, please open an issue first to discuss the design before writing code. This prevents wasted effort and ensures alignment with the project's direction.
+
+---
+
+## Getting Started
+
+1. **Fork** the repository on GitHub.
+2. **Clone** your fork locally:
+   ```bash
+   git clone https://github.com/<your-username>/picoclaw.git
+   cd picoclaw
+   ```
+3. Add the upstream remote:
+   ```bash
+   git remote add upstream https://github.com/sipeed/picoclaw.git
+   ```
+
+---
+
+## Development Setup
+
+### Prerequisites
+
+- Go 1.25 or later
+- `make`
+
+### Build
+
+```bash
+make build       # Build binary (runs go generate first)
+make generate    # Run go generate only
+make check       # Full pre-commit check: deps + fmt + vet + test
+```
+
+### Running Tests
+
+```bash
+make test                                    # Run all tests
+go test -run TestName -v ./pkg/session/      # Run a single test
+go test -bench=. -benchmem -run='^$' ./...  # Run benchmarks
+```
+
+### Code Style
+
+```bash
+make fmt   # Format code
+make vet   # Static analysis
+make lint  # Full linter run
+```
+
+All CI checks must pass before a PR can be merged. Run `make check` locally before pushing to catch issues early.
+
+---
+
+## Making Changes
+
+### Branching
+
+Always branch off `main` and target `main` in your PR. Never push directly to `main` or any `release/*` branch:
+
+```bash
+git checkout main
+git pull upstream main
+git checkout -b your-feature-branch
+```
+
+Use descriptive branch names, e.g. `fix/telegram-timeout`, `feat/ollama-provider`, `docs/contributing-guide`.
+
+### Commits
+
+- Write clear, concise commit messages in English.
+- Use the imperative mood: "Add retry logic" not "Added retry logic".
+- Reference the related issue when relevant: `Fix session leak (#123)`.
+- Keep commits focused. One logical change per commit is preferred.
+- For minor cleanups or typo fixes, squash them into a single commit before opening a PR.
+- Refer to https://www.conventionalcommits.org/zh-hans/v1.0.0/
+
+### Keeping Up to Date
+
+Rebase your branch onto upstream `main` before opening a PR:
+
+```bash
+git fetch upstream
+git rebase upstream/main
+```
+
+---
+
+## AI-Assisted Contributions
+
+PicoClaw was built with substantial AI assistance, and we fully embrace AI-assisted development. However, contributors must understand their responsibilities when using AI tools.
+
+### Disclosure Is Required
+
+Every PR must disclose AI involvement using the PR template's **🤖 AI Code Generation** section. There are three levels:
+
+| Level | Description |
+|---|---|
+| 🤖 Fully AI-generated | AI wrote the code; contributor reviewed and validated it |
+| 🛠️ Mostly AI-generated | AI produced the draft; contributor made significant modifications |
+| 👨‍💻 Mostly Human-written | Contributor led; AI provided suggestions or none at all |
+
+Honest disclosure is expected. There is no stigma attached to any level — what matters is the quality of the contribution.
+
+### You Are Responsible for What You Submit
+
+Using AI to generate code does not reduce your responsibility as the contributor. Before opening a PR with AI-generated code, you must:
+
+- **Read and understand** every line of the generated code.
+- **Test it** in a real environment (see the Test Environment section of the PR template).
+- **Check for security issues** — AI models can generate subtly insecure code (e.g., path traversal, injection, credential exposure). Review carefully.
+- **Verify correctness** — AI-generated logic can be plausible-sounding but wrong. Validate the behavior, not just the syntax.
+
+PRs where it is clear the contributor has not read or tested the AI-generated code will be closed without review.
+
+### AI-Generated Code Quality Standards
+
+AI-generated contributions are held to the **same quality bar** as human-written code:
+
+- It must pass all CI checks (`make check`).
+- It must be idiomatic Go and consistent with the existing codebase style.
+- It must not introduce unnecessary abstractions, dead code, or over-engineering.
+- It must include or update tests where appropriate.
+
+### Security Review
+
+AI-generated code requires extra security scrutiny. Pay special attention to:
+
+- File path handling and sandbox escapes (see commit `244eb0b` for a real example)
+- External input validation in channel handlers and tool implementations
+- Credential or secret handling
+- Command execution (`exec.Command`, shell invocations)
+
+If you are unsure whether a piece of AI-generated code is safe, say so in the PR — reviewers will help.
+
+---
+
+## Pull Request Process
+
+### Before Opening a PR
+
+- [ ] Run `make check` and ensure it passes locally.
+- [ ] Fill in the PR template completely, including the AI disclosure section.
+- [ ] Link any related issue(s) in the PR description.
+- [ ] Keep the PR focused. Avoid bundling unrelated changes together.
+
+### PR Template Sections
+
+The PR template asks for:
+
+- **Description** — What does this change do and why?
+- **Type of Change** — Bug fix, feature, docs, or refactor.
+- **AI Code Generation** — Disclosure of AI involvement (required).
+- **Related Issue** — Link to the issue this addresses.
+- **Technical Context** — Reference URLs and reasoning (skip for pure docs PRs).
+- **Test Environment** — Hardware, OS, model/provider, and channels used for testing.
+- **Evidence** — Optional logs or screenshots demonstrating the change works.
+- **Checklist** — Self-review confirmation.
+
+### PR Size
+
+Prefer small, reviewable PRs. A PR that changes 200 lines across 5 files is much easier to review than one that changes 2000 lines across 30 files. If your feature is large, consider splitting it into a series of smaller, logically complete PRs.
+
+---
+
+## Branch Strategy
+
+### Long-Lived Branches
+
+- **`main`** — the active development branch. All feature PRs target `main`. The branch is protected: direct pushes are not permitted, and at least one maintainer approval is required before merging.
+- **`release/x.y`** — stable release branches, cut from `main` when a version is ready to ship. These branches are more strictly protected than `main`.
+
+### Requirements to Merge into `main`
+
+A PR can only be merged when all of the following are satisfied:
+
+1. **CI passes** — All GitHub Actions workflows (lint, test, build) must be green.
+2. **Reviewer approval** — At least one maintainer has approved the PR.
+3. **No unresolved review comments** — All review threads must be resolved.
+4. **PR template is complete** — Including AI disclosure and test environment.
+
+### Who Can Merge
+
+Only maintainers can merge PRs. Contributors cannot merge their own PRs, even if they have write access.
+
+### Merge Strategy
+
+We use **squash merge** for most PRs to keep the `main` history clean and readable. Each merged PR becomes a single commit referencing the PR number, e.g.:
+
+```
+feat: Add Ollama provider support (#491)
+```
+
+If a PR consists of multiple independent, well-separated commits that tell a clear story, a regular merge may be used at the maintainer's discretion.
+
+### Release Branches
+
+When a version is ready, maintainers cut a `release/x.y` branch from `main`. After that point:
+
+- **New features are not backported.** The release branch receives no new functionality after it is cut.
+- **Security fixes and critical bug fixes are cherry-picked.** If a fix in `main` qualifies (security vulnerability, data loss, crash), maintainers will cherry-pick the relevant commit(s) onto the affected `release/x.y` branch and issue a patch release.
+
+If you believe a fix in `main` should be backported to a release branch, note it in the PR description or open a separate issue. The decision rests with the maintainers.
+
+Release branches have stricter protections than `main` and are never directly pushed to under any circumstances.
+
+---
+
+## Code Review
+
+### For Contributors
+
+- Respond to review comments within a reasonable time. If you need more time, say so.
+- When you update a PR in response to feedback, briefly note what changed (e.g., "Updated to use `sync.RWMutex` as suggested").
+- If you disagree with feedback, engage respectfully. Explain your reasoning; reviewers can be wrong too.
+- Do not force-push after a review has started — it makes it harder for reviewers to see what changed. Use additional commits instead; the maintainer will squash on merge.
+
+### For Reviewers
+
+Review for:
+
+1. **Correctness** — Does the code do what it claims? Are there edge cases?
+2. **Security** — Especially for AI-generated code, tool implementations, and channel handlers.
+3. **Architecture** — Is the approach consistent with the existing design?
+4. **Simplicity** — Is there a simpler solution? Does this add unnecessary complexity?
+5. **Tests** — Are the changes covered by tests? Are existing tests still meaningful?
+
+Be constructive and specific. "This could have a race condition if two goroutines call this concurrently — consider using a mutex here" is better than "this looks wrong".
+
+
+### Reviewer List
+Once your PR is submitted, you can reach out to the assigned reviewers listed in the following table.
+
+|Function| Reviewer|
+|---     |---      |
+|Provider|@yinwm   |
+|Channel |@yinwm   |
+|Agent   |@lxowalle|
+|Tools   |@lxowalle|
+|SKill   ||
+|MCP     ||
+|Optimization|@lxowalle|
+|Security||
+|AI CI   |@imguoguo|
+|UX      ||
+|Document||
+
+---
+
+## Communication
+
+- **GitHub Issues** — Bug reports, feature requests, design discussions.
+- **GitHub Discussions** — General questions, ideas, community conversation.
+- **Pull Request comments** — Code-specific feedback.
+- **Wechat&Discord** — We will invite you when you have at least one merged PR
+
+When in doubt, open an issue before writing code. It costs little and prevents wasted effort.
+
+---
+
+## A Note on the Project's AI-Driven Origin
+
+PicoClaw's architecture was substantially designed and implemented with AI assistance, guided by human oversight. If you find something that looks odd or over-engineered, it may be an artifact of that process — opening an issue to discuss it is always welcome.
+
+We believe AI-assisted development done responsibly produces great results. We also believe humans must remain accountable for what they ship. These two beliefs are not in conflict.
+
+Thank you for contributing!
diff --git a/CONTRIBUTING.zh.md b/CONTRIBUTING.zh.md
new file mode 100644
index 000000000..01a1abfd5
--- /dev/null
+++ b/CONTRIBUTING.zh.md
@@ -0,0 +1,303 @@
+# 参与贡献 PicoClaw
+
+感谢你对 PicoClaw 的关注！本项目是一个社区驱动的开源项目，目标是构建 轻量灵活,人人可用 的个人AI助手。我们欢迎一切形式的贡献：Bug 修复、新功能、文档、翻译和测试。
+
+PicoClaw 本身在很大程度上是借助 AI 辅助开发的——我们拥抱这种方式，并围绕它构建了贡献流程。
+
+## 目录
+
+- [行为准则](#行为准则)
+- [贡献方式](#贡献方式)
+- [快速开始](#快速开始)
+- [开发环境配置](#开发环境配置)
+- [提交修改](#提交修改)
+- [AI 辅助贡献](#ai-辅助贡献)
+- [Pull Request 流程](#pull-request-流程)
+- [分支策略](#分支策略)
+- [代码审查](#代码审查)
+- [沟通渠道](#沟通渠道)
+
+---
+
+## 行为准则
+
+我们致力于维护一个友好、互相尊重的社区环境。请保持善意、建设性的态度，并善意地理解他人。任何形式的骚扰或歧视均不被接受。
+
+---
+
+## 贡献方式
+
+- **Bug 反馈** — 使用 Bug 报告模板提交 Issue。
+- **功能建议** — 使用功能请求模板提交 Issue，建议在开始实现前先进行讨论。
+- **代码贡献** — 修复 Bug 或实现新功能，参见下方工作流程。
+- **文档改进** — 完善 README、文档、代码注释或翻译。
+- **测试与验证** — 在新硬件、新渠道或新 LLM 提供商上运行 PicoClaw 并反馈结果。
+
+对于较大的新功能，请先提交 Issue 讨论设计方案，再动手写代码。这能避免无效投入，也确保与项目方向保持一致。
+
+---
+
+## 快速开始
+
+1. 在 GitHub 上 **Fork** 本仓库。
+2. 将你的 Fork **克隆**到本地：
+   ```bash
+   git clone https://github.com/<你的用户名>/picoclaw.git
+   cd picoclaw
+   ```
+3. 添加上游远程仓库：
+   ```bash
+   git remote add upstream https://github.com/sipeed/picoclaw.git
+   ```
+
+---
+
+## 开发环境配置
+
+### 前置依赖
+
+- Go 1.25 或更高版本
+- `make`
+
+### 构建
+
+```bash
+make build       # 构建二进制文件（会先执行 go generate）
+make generate    # 仅执行 go generate
+make check       # 完整的提交前检查：deps + fmt + vet + test
+```
+
+### 运行测试
+
+```bash
+make test                                    # 运行所有测试
+go test -run TestName -v ./pkg/session/      # 运行单个测试
+go test -bench=. -benchmem -run='^$' ./...  # 运行基准测试
+```
+
+### 代码风格
+
+```bash
+make fmt   # 格式化代码
+make vet   # 静态分析
+make lint  # 完整的 lint 检查
+```
+
+所有 CI 检查通过后 PR 才能被合并。推送代码前请先在本地运行 `make check`，提前发现问题。
+
+---
+
+## 提交修改
+
+### 分支管理
+
+始终从 `main` 分支切出，并在 PR 中以 `main` 为目标分支。不要直接向 `main` 或任何 `release/*` 分支推送代码：
+
+```bash
+git checkout main
+git pull upstream main
+git checkout -b 你的功能分支名
+```
+
+请使用描述性的分支名，例如：`fix/telegram-timeout`、`feat/ollama-provider`、`docs/contributing-guide`。
+
+### Commit 规范
+
+- 使用英文撰写清晰、简洁的 commit 信息。
+- 使用祈使句：写 "Add retry logic"，而不是 "Added retry logic"。
+- 有关联 Issue 时请引用：`Fix session leak (#123)`。
+- 保持 commit 专注，每个 commit 只做一件事。
+- 对于小的清理或拼写修正，提 PR 前请将其合并为一个 commit。
+- 按照 https://www.conventionalcommits.org/zh-hans/v1.0.0/ 规范来撰写
+
+### 保持与上游同步
+
+提 PR 前，请将你的分支变基到上游 `main`：
+
+```bash
+git fetch upstream
+git rebase upstream/main
+```
+
+---
+
+## AI 辅助贡献
+
+PicoClaw 在很大程度上借助 AI 辅助开发，我们完全拥抱这种开发方式。但贡献者必须清楚地了解自己在使用 AI 工具时所承担的责任。
+
+### 必须披露 AI 使用情况
+
+每个 PR 都必须通过 PR 模板中的 **🤖 AI 代码生成** 部分披露 AI 参与情况，共分三个级别：
+
+| 级别 | 说明 |
+|---|---|
+| 🤖 完全由 AI 生成 | AI 编写代码，贡献者负责审查和验证 |
+| 🛠️ 主要由 AI 生成 | AI 起草，贡献者做了较大修改 |
+| 👨‍💻 主要由人工编写 | 贡献者主导，AI 仅提供辅助或未使用 AI |
+
+我们期望你诚实填写。三种级别均可接受，没有任何歧视——重要的是贡献的质量。
+
+### 你对提交的代码负全责
+
+使用 AI 生成代码并不能减轻你作为贡献者的责任。在提交含有 AI 生成代码的 PR 之前，你必须：
+
+- **逐行阅读并理解**生成的代码。
+- **在真实环境中测试**（参见 PR 模板中的测试环境部分）。
+- **检查安全问题** — AI 模型可能生成存在安全隐患的代码（如路径穿越、注入攻击、凭据泄露等），请仔细审查。
+- **验证正确性** — AI 生成的逻辑可能听起来合理但实际上是错误的，请验证行为，而不仅仅是语法。
+
+如果明显可以看出贡献者没有阅读或测试 AI 生成的代码，该 PR 将被直接关闭，不予审查。
+
+### AI 生成代码的质量标准
+
+AI 生成的代码与人工编写的代码遵循**相同的质量要求**：
+
+- 必须通过所有 CI 检查（`make check`）。
+- 必须符合 Go 惯用写法，并与现有代码库的风格保持一致。
+- 不得引入不必要的抽象、死代码或过度设计。
+- 须在适当的地方包含或更新测试。
+
+### 安全审查
+
+AI 生成的代码需要格外仔细的安全审查。请特别关注以下方面：
+
+- 文件路径处理与沙箱逃逸（项目历史中的 commit `244eb0b` 就是真实案例）
+- channel 处理器和 tool 实现中的外部输入校验
+- 凭据或密钥的处理
+- 命令执行（`exec.Command`、shell 调用等）
+
+如果你不确定某段 AI 生成代码是否安全，请在 PR 中说明——审查者会帮助判断。
+
+---
+
+## Pull Request 流程
+
+### 提 PR 前的检查
+
+- [ ] 在本地运行 `make check` 并确认通过。
+- [ ] 完整填写 PR 模板，包括 AI 披露部分。
+- [ ] 在 PR 描述中关联相关 Issue。
+- [ ] 保持 PR 专注，避免将不相关的修改混在一起。
+
+### PR 模板各部分说明
+
+PR 模板要求填写：
+
+- **描述** — 这个改动做了什么，为什么要做？
+- **变更类型** — Bug 修复、新功能、文档或重构。
+- **AI 代码生成** — AI 参与情况披露（必填）。
+- **关联 Issue** — 此 PR 解决的 Issue 链接。
+- **技术背景** — 参考链接和设计理由（纯文档类 PR 可跳过）。
+- **测试环境** — 用于测试的硬件、操作系统、模型/提供商和渠道。
+- **验证证据** — 可选的日志或截图，用于证明改动有效。
+- **检查清单** — 自我审查确认。
+
+### PR 规模
+
+请尽量提交小而易于审查的 PR。一个涉及 5 个文件共 200 行改动的 PR，远比涉及 30 个文件共 2000 行改动的 PR 容易审查。如果你的功能较大，可以考虑将其拆分为一系列逻辑完整的小 PR。
+
+---
+
+## 分支策略
+
+### 长期分支
+
+- **`main`** — 活跃开发分支。所有功能 PR 均以 `main` 为目标。该分支受保护：禁止直接推送，合并前必须获得至少一名维护者的批准。
+- **`release/x.y`** — 稳定发布分支，在某个版本准备发布时从 `main` 切出。这些分支的保护级别高于 `main`。
+
+### 合并到 `main` 的前提条件
+
+PR 必须同时满足以下所有条件，才能被合并：
+
+1. **CI 全部通过** — 所有 GitHub Actions 工作流（lint、test、build）均为绿色。
+2. **获得审查者批准** — 至少一名维护者已批准该 PR。
+3. **无未解决的审查意见** — 所有审查讨论线程均已关闭。
+4. **PR 模板填写完整** — 包括 AI 披露和测试环境信息。
+
+### 谁可以合并
+
+只有维护者才能合并 PR。贡献者不能合并自己的 PR，即使拥有写权限也不行。
+
+### 合并策略
+
+为保持 `main` 历史清晰可读，我们对大多数 PR 使用 **Squash Merge**。每个合并的 PR 变为一个包含 PR 编号的单独 commit，例如：
+
+```
+feat: Add Ollama provider support (#491)
+```
+
+如果一个 PR 包含多个独立、结构清晰、能讲述完整故事的 commit，维护者可视情况使用普通 merge。
+
+### Release 分支
+
+当某个版本准备就绪时，维护者会从 `main` 切出 `release/x.y` 分支。此后：
+
+- **新功能不会被回溯（backport）。** Release 分支切出后，不再接收任何新功能。
+- **安全修复和关键 Bug 修复会被 cherry-pick 进来。** 若 `main` 上的某个修复属于安全漏洞、数据丢失或崩溃类问题，维护者会将相关 commit cherry-pick 到受影响的 `release/x.y` 分支，并发布补丁版本。
+
+如果你认为 `main` 上的某个修复应该被回溯到某个 release 分支，请在 PR 描述中注明，或单独开一个 Issue 说明。最终决定由维护者做出。
+
+Release 分支的保护级别高于 `main`，在任何情况下均不允许直接推送。
+
+---
+
+## 代码审查
+
+### 对贡献者的建议
+
+- 在合理时间内回复审查意见。如果需要更多时间，请告知。
+- 更新 PR 以响应反馈时，简要说明改动内容（例如："按建议改用了 `sync.RWMutex`"）。
+- 如果你不同意某条反馈，请礼貌地阐述你的理由——审查者也可能有判断失误的时候。
+- 审查开始后请不要 force push——这会让审查者难以追踪变化。请使用额外的 commit，维护者在合并时会进行 squash。
+
+### 对审查者的建议
+
+审查重点：
+
+1. **正确性** — 代码是否实现了其声称的功能？是否存在边界情况？
+2. **安全性** — 对 AI 生成代码、tool 实现和 channel 处理器尤其需要关注。
+3. **架构** — 实现方式是否与现有设计一致？
+4. **简洁性** — 是否有更简单的方案？是否引入了不必要的复杂度？
+5. **测试** — 改动是否有测试覆盖？现有测试是否仍然有意义？
+
+请给出建设性且具体的反馈。"如果两个 goroutine 同时调用这个函数可能会有竞态条件，建议在这里加一个 mutex" 远比 "这里看起来有问题" 更有帮助。
+
+### 审查者列表
+提交对应PR后，可以参考下表联系对应的审查人员沟通
+
+|Function| Reviewer|
+|---     |---      |
+|Provider|@yinwm   |
+|Channel |@yinwm   |
+|Agent   |@lxowalle|
+|Tools   |@lxowalle|
+|SKill   ||
+|MCP     ||
+|Optimization|@lxowalle|
+|Security||
+|AI CI   |@imguoguo|
+|UX      ||
+|Document||
+
+
+
+---
+
+## 沟通渠道
+
+- **GitHub Issues** — Bug 报告、功能建议、设计讨论。
+- **GitHub Discussions** — 一般性问题、想法交流、社区讨论。
+- **Pull Request 评论** — 与具体代码相关的反馈。
+- **Wechat&Discord** — 当你有至少一个已合并的PR后，我们会邀请你加入开发者交流群
+
+有疑问时，请先开 Issue 讨论，再动手写代码。这几乎没有成本，却能避免大量无效投入。
+
+---
+
+## 关于本项目的 AI 驱动起源
+
+PicoClaw 的架构在人工监督下，经由 AI 辅助完成了大量设计和实现工作。如果你发现某处看起来奇怪或过度设计，这可能是该过程留下的痕迹——欢迎提 Issue 讨论。
+
+我们相信，负责任地使用 AI 辅助开发能产生优秀的成果。我们同样相信，人类必须对自己提交的内容负责。这两点并不矛盾。
+
+感谢你的贡献！
diff --git a/assets/wechat.png b/assets/wechat.png
index 8fc41ea7d53cfc9e0ccb7b6fe5a4fd6d079cee7c..a34217c335542a13aace2103bd15ccebf94acde2 100644
GIT binary patch
literal 144045
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

literal 144319
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
ZcS`}Nmr^nhTC?^iWQVnMgke}I{a<4CA~*m5


From c51ceac70b66acc30d42a31e9f77d784b190890c Mon Sep 17 00:00:00 2001
From: Albert Simon <47634918+willyw0nka@users.noreply.github.com>
Date: Sat, 21 Feb 2026 23:53:53 +0100
Subject: [PATCH 09/52] fix: updated model configuration links at readme (#544)

Signed-off-by: Albert Simon <simon.albert75@gmail.com>

From b9a66248d8fd88644f1fec3f8be35fbbc23d4803 Mon Sep 17 00:00:00 2001
From: kernoeb <kernoeb@protonmail.com>
Date: Sun, 22 Feb 2026 01:32:44 +0100
Subject: [PATCH 10/52] fix: resolve Groq STT key from model_list when
 providers.groq is absent (#602)

When users migrate from the legacy `providers` config to the new
`model_list` format, voice transcription silently breaks on Telegram,
Discord and Slack channels.

The gateway was reading the Groq API key exclusively from
`cfg.Providers.Groq.APIKey`, which is empty once the key is defined
only inside a `model_list` entry. The transcriber was never initialized,
so voice messages fell back to a plain `[voice]` placeholder.

This fix also scans `model_list` for any entry whose `model` field
starts with `groq/` and uses its `api_key` as a fallback, preserving
full backward compatibility with the legacy `providers.groq` field.
---
 cmd/picoclaw/cmd_gateway.go | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 9a3b6aa19..28ef76ad3 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -10,6 +10,7 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/sipeed/picoclaw/pkg/agent"
@@ -121,8 +122,17 @@ func gatewayCmd() {
 	agentLoop.SetChannelManager(channelManager)
 
 	var transcriber *voice.GroqTranscriber
-	if cfg.Providers.Groq.APIKey != "" {
-		transcriber = voice.NewGroqTranscriber(cfg.Providers.Groq.APIKey)
+	groqAPIKey := cfg.Providers.Groq.APIKey
+	if groqAPIKey == "" {
+		for _, mc := range cfg.ModelList {
+			if strings.HasPrefix(mc.Model, "groq/") && mc.APIKey != "" {
+				groqAPIKey = mc.APIKey
+				break
+			}
+		}
+	}
+	if groqAPIKey != "" {
+		transcriber = voice.NewGroqTranscriber(groqAPIKey)
 		logger.InfoC("voice", "Groq voice transcription enabled")
 	}
 

From cec6fd4cd4689bac068b4710aed0b26e98c77541 Mon Sep 17 00:00:00 2001
From: Yoftahe Abraham <jofab08@gmail.com>
Date: Sun, 22 Feb 2026 10:27:38 +0300
Subject: [PATCH 11/52] fix: should use fmt.Printf instead of
 fmt.Print(fmt.Sprintf(...)) (#623)

---
 cmd/picoclaw/cmd_agent.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/picoclaw/cmd_agent.go b/cmd/picoclaw/cmd_agent.go
index 6d6ff935f..8658c9d32 100644
--- a/cmd/picoclaw/cmd_agent.go
+++ b/cmd/picoclaw/cmd_agent.go
@@ -148,7 +148,7 @@ func interactiveMode(agentLoop *agent.AgentLoop, sessionKey string) {
 func simpleInteractiveMode(agentLoop *agent.AgentLoop, sessionKey string) {
 	reader := bufio.NewReader(os.Stdin)
 	for {
-		fmt.Print(fmt.Sprintf("%s You: ", logo))
+		fmt.Printf("%s You: ", logo)
 		line, err := reader.ReadString('\n')
 		if err != nil {
 			if err == io.EOF {

From 65422a16a4f9a04ecc55b066b800e92859b9f376 Mon Sep 17 00:00:00 2001
From: Edouard CLAUDE <edouard-claude@users.noreply.github.com>
Date: Fri, 20 Feb 2026 19:31:35 +0400
Subject: [PATCH 12/52] feat: add native Mistral AI provider support
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add Mistral as a first-class provider alongside the 17 existing ones.
Mistral uses the OpenAI-compatible API at https://api.mistral.ai/v1
with provider-specific model prefix stripping (mistral/model → model).

Changes:
- Add Mistral to ProvidersConfig, IsEmpty(), HasProvidersConfig()
- Add mistral entry in default model_list (defaults.go)
- Add mistral protocol in factory_provider.go and getDefaultAPIBase()
- Add mistral prefix stripping in openai_compat normalizeModel()
- Add mistral case in legacy factory.go resolveProviderSelection()
- Add mistral migration entry in ConvertProvidersToModelList()
- Add mistral to supported providers in migrate/config.go
- Add mistral section in config.example.json
- Update AllProviders test (17 → 18 providers)

Tested end-to-end with mistral-small-latest model.
---
 config/config.example.json              |  4 ++++
 pkg/config/config.go                    |  7 +++++--
 pkg/config/defaults.go                  |  8 ++++++++
 pkg/config/migration.go                 | 16 ++++++++++++++++
 pkg/config/migration_test.go            |  7 ++++---
 pkg/migrate/config.go                   |  1 +
 pkg/providers/factory.go                | 16 ++++++++++++++++
 pkg/providers/factory_provider.go       |  4 +++-
 pkg/providers/openai_compat/provider.go |  2 +-
 9 files changed, 58 insertions(+), 7 deletions(-)

diff --git a/config/config.example.json b/config/config.example.json
index 77a8c0683..e814fcbb8 100644
--- a/config/config.example.json
+++ b/config/config.example.json
@@ -196,6 +196,10 @@
     "volcengine": {
       "api_key": "",
       "api_base": ""
+    },
+    "mistral": {
+      "api_key": "",
+      "api_base": "https://api.mistral.ai/v1"
     }
   },
   "tools": {
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 20556011a..440ac5436 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -324,6 +324,7 @@ type ProvidersConfig struct {
 	GitHubCopilot ProviderConfig       `json:"github_copilot"`
 	Antigravity   ProviderConfig       `json:"antigravity"`
 	Qwen          ProviderConfig       `json:"qwen"`
+	Mistral       ProviderConfig       `json:"mistral"`
 }
 
 // IsEmpty checks if all provider configs are empty (no API keys or API bases set)
@@ -345,7 +346,8 @@ func (p ProvidersConfig) IsEmpty() bool {
 		p.VolcEngine.APIKey == "" && p.VolcEngine.APIBase == "" &&
 		p.GitHubCopilot.APIKey == "" && p.GitHubCopilot.APIBase == "" &&
 		p.Antigravity.APIKey == "" && p.Antigravity.APIBase == "" &&
-		p.Qwen.APIKey == "" && p.Qwen.APIBase == ""
+		p.Qwen.APIKey == "" && p.Qwen.APIBase == "" &&
+		p.Mistral.APIKey == "" && p.Mistral.APIBase == ""
 }
 
 // MarshalJSON implements custom JSON marshaling for ProvidersConfig
@@ -636,7 +638,8 @@ func (c *Config) HasProvidersConfig() bool {
 		v.VolcEngine.APIKey != "" || v.VolcEngine.APIBase != "" ||
 		v.GitHubCopilot.APIKey != "" || v.GitHubCopilot.APIBase != "" ||
 		v.Antigravity.APIKey != "" || v.Antigravity.APIBase != "" ||
-		v.Qwen.APIKey != "" || v.Qwen.APIBase != ""
+		v.Qwen.APIKey != "" || v.Qwen.APIBase != "" ||
+		v.Mistral.APIKey != "" || v.Mistral.APIBase != ""
 }
 
 // ValidateModelList validates all ModelConfig entries in the model_list.
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index 7654326e7..065273c28 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -255,6 +255,14 @@ func DefaultConfig() *Config {
 				APIKey:    "ollama",
 			},
 
+			// Mistral AI - https://console.mistral.ai/api-keys
+			{
+				ModelName: "mistral-small",
+				Model:     "mistral/mistral-small-latest",
+				APIBase:   "https://api.mistral.ai/v1",
+				APIKey:    "",
+			},
+
 			// VLLM (local) - http://localhost:8000
 			{
 				ModelName: "local-model",
diff --git a/pkg/config/migration.go b/pkg/config/migration.go
index 689e2312f..30eaa7474 100644
--- a/pkg/config/migration.go
+++ b/pkg/config/migration.go
@@ -324,6 +324,22 @@ func ConvertProvidersToModelList(cfg *Config) []ModelConfig {
 				}, true
 			},
 		},
+		{
+			providerNames: []string{"mistral"},
+			protocol:      "mistral",
+			buildConfig: func(p ProvidersConfig) (ModelConfig, bool) {
+				if p.Mistral.APIKey == "" && p.Mistral.APIBase == "" {
+					return ModelConfig{}, false
+				}
+				return ModelConfig{
+					ModelName: "mistral",
+					Model:     "mistral/mistral-small-latest",
+					APIKey:    p.Mistral.APIKey,
+					APIBase:   p.Mistral.APIBase,
+					Proxy:     p.Mistral.Proxy,
+				}, true
+			},
+		},
 	}
 
 	// Process each provider migration
diff --git a/pkg/config/migration_test.go b/pkg/config/migration_test.go
index 1e8139e68..42165cb71 100644
--- a/pkg/config/migration_test.go
+++ b/pkg/config/migration_test.go
@@ -131,14 +131,15 @@ func TestConvertProvidersToModelList_AllProviders(t *testing.T) {
 			GitHubCopilot: ProviderConfig{ConnectMode: "grpc"},
 			Antigravity:   ProviderConfig{AuthMethod: "oauth"},
 			Qwen:          ProviderConfig{APIKey: "key17"},
+			Mistral:       ProviderConfig{APIKey: "key18"},
 		},
 	}
 
 	result := ConvertProvidersToModelList(cfg)
 
-	// All 17 providers should be converted
-	if len(result) != 17 {
-		t.Errorf("len(result) = %d, want 17", len(result))
+	// All 18 providers should be converted
+	if len(result) != 18 {
+		t.Errorf("len(result) = %d, want 18", len(result))
 	}
 }
 
diff --git a/pkg/migrate/config.go b/pkg/migrate/config.go
index 2237a1429..24ce33e94 100644
--- a/pkg/migrate/config.go
+++ b/pkg/migrate/config.go
@@ -22,6 +22,7 @@ var supportedProviders = map[string]bool{
 	"qwen":           true,
 	"deepseek":       true,
 	"github_copilot": true,
+	"mistral":        true,
 }
 
 var supportedChannels = map[string]bool{
diff --git a/pkg/providers/factory.go b/pkg/providers/factory.go
index b6f1b5e21..cda4753ea 100644
--- a/pkg/providers/factory.go
+++ b/pkg/providers/factory.go
@@ -172,6 +172,15 @@ func resolveProviderSelection(cfg *config.Config) (providerSelection, error) {
 					sel.model = "deepseek-chat"
 				}
 			}
+		case "mistral":
+			if cfg.Providers.Mistral.APIKey != "" {
+				sel.apiKey = cfg.Providers.Mistral.APIKey
+				sel.apiBase = cfg.Providers.Mistral.APIBase
+				sel.proxy = cfg.Providers.Mistral.Proxy
+				if sel.apiBase == "" {
+					sel.apiBase = "https://api.mistral.ai/v1"
+				}
+			}
 		case "github_copilot", "copilot":
 			sel.providerType = providerTypeGitHubCopilot
 			if cfg.Providers.GitHubCopilot.APIBase != "" {
@@ -275,6 +284,13 @@ func resolveProviderSelection(cfg *config.Config) (providerSelection, error) {
 			if sel.apiBase == "" {
 				sel.apiBase = "http://localhost:11434/v1"
 			}
+		case (strings.Contains(lowerModel, "mistral") || strings.HasPrefix(model, "mistral/")) && cfg.Providers.Mistral.APIKey != "":
+			sel.apiKey = cfg.Providers.Mistral.APIKey
+			sel.apiBase = cfg.Providers.Mistral.APIBase
+			sel.proxy = cfg.Providers.Mistral.Proxy
+			if sel.apiBase == "" {
+				sel.apiBase = "https://api.mistral.ai/v1"
+			}
 		case cfg.Providers.VLLM.APIBase != "":
 			sel.apiKey = cfg.Providers.VLLM.APIKey
 			sel.apiBase = cfg.Providers.VLLM.APIBase
diff --git a/pkg/providers/factory_provider.go b/pkg/providers/factory_provider.go
index 74fe8a36c..7d5566eef 100644
--- a/pkg/providers/factory_provider.go
+++ b/pkg/providers/factory_provider.go
@@ -88,7 +88,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err
 
 	case "openrouter", "groq", "zhipu", "gemini", "nvidia",
 		"ollama", "moonshot", "shengsuanyun", "deepseek", "cerebras",
-		"volcengine", "vllm", "qwen":
+		"volcengine", "vllm", "qwen", "mistral":
 		// All other OpenAI-compatible HTTP providers
 		if cfg.APIKey == "" && cfg.APIBase == "" {
 			return nil, "", fmt.Errorf("api_key or api_base is required for HTTP-based protocol %q", protocol)
@@ -186,6 +186,8 @@ func getDefaultAPIBase(protocol string) string {
 		return "https://dashscope.aliyuncs.com/compatible-mode/v1"
 	case "vllm":
 		return "http://localhost:8000/v1"
+	case "mistral":
+		return "https://api.mistral.ai/v1"
 	default:
 		return ""
 	}
diff --git a/pkg/providers/openai_compat/provider.go b/pkg/providers/openai_compat/provider.go
index b8528953a..236a048c4 100644
--- a/pkg/providers/openai_compat/provider.go
+++ b/pkg/providers/openai_compat/provider.go
@@ -240,7 +240,7 @@ func normalizeModel(model, apiBase string) string {
 
 	prefix := strings.ToLower(model[:idx])
 	switch prefix {
-	case "moonshot", "nvidia", "groq", "ollama", "deepseek", "google", "openrouter", "zhipu":
+	case "moonshot", "nvidia", "groq", "ollama", "deepseek", "google", "openrouter", "zhipu", "mistral":
 		return model[idx+1:]
 	default:
 		return model

From 34a8ce5af05618057837db05828f3867e6cd4fdf Mon Sep 17 00:00:00 2001
From: Edouard CLAUDE <edouard-claude@users.noreply.github.com>
Date: Sat, 21 Feb 2026 05:32:18 +0400
Subject: [PATCH 13/52] fix: remove extra fields from ToolCall JSON
 serialization

Mistral's API strictly validates tool_calls in assistant messages and
rejects non-standard fields. The ToolCall struct had Name and Arguments
as top-level JSON fields, duplicating data already in Function.Name
and Function.Arguments. OpenAI silently ignored these extras but
Mistral returns 422.

Change json tags to "-" so these internal fields are no longer
serialized to API payloads while remaining available in Go code.
---
 pkg/providers/protocoltypes/types.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/providers/protocoltypes/types.go b/pkg/providers/protocoltypes/types.go
index 3a089ca47..5e1c6d397 100644
--- a/pkg/providers/protocoltypes/types.go
+++ b/pkg/providers/protocoltypes/types.go
@@ -4,8 +4,8 @@ type ToolCall struct {
 	ID               string         `json:"id"`
 	Type             string         `json:"type,omitempty"`
 	Function         *FunctionCall  `json:"function,omitempty"`
-	Name             string         `json:"name,omitempty"`
-	Arguments        map[string]any `json:"arguments,omitempty"`
+	Name             string         `json:"-"`
+	Arguments        map[string]any `json:"-"`
 	ThoughtSignature string         `json:"-"` // Internal use only
 	ExtraContent     *ExtraContent  `json:"extra_content,omitempty"`
 }

From 6b55fb5f1df3ee6852c31d579b3dc04b742cc704 Mon Sep 17 00:00:00 2001
From: Ali Zulfiqar <codewithfourtix@gmail.com>
Date: Sun, 22 Feb 2026 15:00:15 +0500
Subject: [PATCH 14/52] docs: fix typos, broken links and inconsistencies in
 README (#608)

* docs: fix typos, broken links and inconsistencies in README

* docs: revert unintentional bullet style changes

* docs: fix changes

* docs: fixing issues

* docs: updating roadmap link

* docs: removing *
---
 README.md | 142 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 78 insertions(+), 64 deletions(-)

diff --git a/README.md b/README.md
index 7bc7b1089..de6fd87ea 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,8 @@
     <a href="https://x.com/SipeedIO"><img src="https://img.shields.io/badge/X_(Twitter)-SipeedIO-black?style=flat&logo=x&logoColor=white" alt="Twitter"></a>
   </p>
 
- [中文](README.zh.md) | [日本語](README.ja.md) | [Português](README.pt-br.md) | [Tiếng Việt](README.vi.md) | [Français](README.fr.md) | **English**
+[中文](README.zh.md) | [日本語](README.ja.md) | [Português](README.pt-br.md) | [Tiếng Việt](README.vi.md) | [Français](README.fr.md) | **English**
+
 </div>
 
 ---
@@ -42,16 +43,17 @@
 > **🚨 SECURITY & OFFICIAL CHANNELS / 安全声明**
 >
 > * **NO CRYPTO:** PicoClaw has **NO** official token/coin. All claims on `pump.fun` or other trading platforms are **SCAMS**.
+>
 > * **OFFICIAL DOMAIN:** The **ONLY** official website is **[picoclaw.io](https://picoclaw.io)**, and company website is **[sipeed.com](https://sipeed.com)**
 > * **Warning:** Many `.ai/.org/.com/.net/...` domains are registered by third parties.
 > * **Warning:** picoclaw is in early development now and may have unresolved network security issues. Do not deploy to production environments before the v1.0 release.
 > * **Note:** picoclaw has recently merged a lot of PRs, which may result in a larger memory footprint (10–20MB) in the latest versions. We plan to prioritize resource optimization as soon as the current feature set reaches a stable state.
 
-
 ## 📢 News
+
 2026-02-16 🎉 PicoClaw hit 12K stars in one week! Thank you all for your support! PicoClaw is growing faster than we ever imagined. Given the high volume of PRs, we urgently need community maintainers. Our volunteer roles and roadmap are officially posted [here](docs/picoclaw_community_roadmap_260216.md) —we can’t wait to have you on board!
 
-2026-02-13 🎉 PicoClaw hit 5000 stars in 4days! Thank you for the community! There are so many PRs&issues come in (during Chinese New Year holidays), we are finalizing the Project Roadmap and setting up the Developer Group to accelerate PicoClaw's development.  
+2026-02-13 🎉 PicoClaw hit 5000 stars in 4days! Thank you for the community! There are so many PRs & issues coming in (during Chinese New Year holidays), we are finalizing the Project Roadmap and setting up the Developer Group to accelerate PicoClaw's development.  
 🚀 Call to Action: Please submit your feature requests in GitHub Discussions. We will review and prioritize them during our upcoming weekly meeting.
 
 2026-02-09 🎉 PicoClaw Launched! Built in 1 day to bring AI Agents to $10 hardware with <10MB RAM. 🦐 PicoClaw，Let's Go！
@@ -100,9 +102,12 @@
 </table>
 
 ### 📱 Run on old Android Phones
+
 Give your decade-old phone a second life! Turn it into a smart AI Assistant with PicoClaw. Quick Start:
+
 1. **Install Termux** (Available on F-Droid or Google Play).
 2. **Execute cmds**
+
 ```bash
 # Note: Replace v0.1.1 with the latest version from the Releases page
 wget https://github.com/sipeed/picoclaw/releases/download/v0.1.1/picoclaw-linux-arm64
@@ -110,6 +115,7 @@ chmod +x picoclaw-linux-arm64
 pkg install proot
 termux-chroot ./picoclaw-linux-arm64 onboard
 ```
+
 And then follow the instructions in the "Quick Start" section to complete the configuration!
 <img src="assets/termux.jpg" alt="PicoClaw" width="512">
 
@@ -323,7 +329,6 @@ picoclaw gateway
 * (Optional) Enable **SERVER MEMBERS INTENT** if you plan to use allow lists based on member data
 
 **3. Get your User ID**
-
 * Discord Settings → Advanced → enable **Developer Mode**
 * Right-click your avatar → **Copy User ID**
 
@@ -425,7 +430,6 @@ picoclaw gateway
 ```bash
 picoclaw gateway
 ```
-
 </details>
 
 <details>
@@ -521,7 +525,6 @@ See [WeCom App Configuration Guide](docs/wecom-app-configuration.md) for detaile
 * Go to WeCom Admin Console → App Management → Create App
 * Copy **AgentId** and **Secret**
 * Go to "My Company" page, copy **CorpID**
-
 **2. Configure receive message**
 
 * In App details, click "Receive Message" → "Set API"
@@ -605,23 +608,23 @@ PicoClaw runs in a sandboxed environment by default. The agent can only access f
 }
 ```
 
-| Option | Default | Description |
-|--------|---------|-------------|
-| `workspace` | `~/.picoclaw/workspace` | Working directory for the agent |
-| `restrict_to_workspace` | `true` | Restrict file/command access to workspace |
+| Option                  | Default                 | Description                               |
+| ----------------------- | ----------------------- | ----------------------------------------- |
+| `workspace`             | `~/.picoclaw/workspace` | Working directory for the agent           |
+| `restrict_to_workspace` | `true`                  | Restrict file/command access to workspace |
 
 #### Protected Tools
 
 When `restrict_to_workspace: true`, the following tools are sandboxed:
 
-| Tool | Function | Restriction |
-|------|----------|-------------|
-| `read_file` | Read files | Only files within workspace |
-| `write_file` | Write files | Only files within workspace |
-| `list_dir` | List directories | Only directories within workspace |
-| `edit_file` | Edit files | Only files within workspace |
-| `append_file` | Append to files | Only files within workspace |
-| `exec` | Execute commands | Command paths must be within workspace |
+| Tool          | Function         | Restriction                            |
+| ------------- | ---------------- | -------------------------------------- |
+| `read_file`   | Read files       | Only files within workspace            |
+| `write_file`  | Write files      | Only files within workspace            |
+| `list_dir`    | List directories | Only directories within workspace      |
+| `edit_file`   | Edit files       | Only files within workspace            |
+| `append_file` | Append to files  | Only files within workspace            |
+| `exec`        | Execute commands | Command paths must be within workspace |
 
 #### Additional Exec Protection
 
@@ -674,11 +677,11 @@ export PICOCLAW_AGENTS_DEFAULTS_RESTRICT_TO_WORKSPACE=false
 
 The `restrict_to_workspace` setting applies consistently across all execution paths:
 
-| Execution Path | Security Boundary |
-|----------------|-------------------|
-| Main Agent | `restrict_to_workspace` ✅ |
+| Execution Path   | Security Boundary            |
+| ---------------- | ---------------------------- |
+| Main Agent       | `restrict_to_workspace` ✅   |
 | Subagent / Spawn | Inherits same restriction ✅ |
-| Heartbeat tasks | Inherits same restriction ✅ |
+| Heartbeat tasks  | Inherits same restriction ✅ |
 
 All paths share the same workspace restriction — there's no way to bypass the security boundary through subagents or scheduled tasks.
 
@@ -704,21 +707,23 @@ For long-running tasks (web search, API calls), use the `spawn` tool to create a
 # Periodic Tasks
 
 ## Quick Tasks (respond directly)
+
 - Report current time
 
 ## Long Tasks (use spawn for async)
+
 - Search the web for AI news and summarize
 - Check email and report important messages
 ```
 
 **Key behaviors:**
 
-| Feature | Description |
-|---------|-------------|
-| **spawn** | Creates async subagent, doesn't block heartbeat |
-| **Independent context** | Subagent has its own context, no session history |
-| **message tool** | Subagent communicates with user directly via message tool |
-| **Non-blocking** | After spawning, heartbeat continues to next task |
+| Feature                 | Description                                               |
+| ----------------------- | --------------------------------------------------------- |
+| **spawn**               | Creates async subagent, doesn't block heartbeat           |
+| **Independent context** | Subagent has its own context, no session history          |
+| **message tool**        | Subagent communicates with user directly via message tool |
+| **Non-blocking**        | After spawning, heartbeat continues to next task          |
 
 #### How Subagent Communication Works
 
@@ -749,10 +754,10 @@ The subagent has access to tools (message, web_search, etc.) and can communicate
 }
 ```
 
-| Option | Default | Description |
-|--------|---------|-------------|
-| `enabled` | `true` | Enable/disable heartbeat |
-| `interval` | `30` | Check interval in minutes (min: 5) |
+| Option     | Default | Description                        |
+| ---------- | ------- | ---------------------------------- |
+| `enabled`  | `true`  | Enable/disable heartbeat           |
+| `interval` | `30`    | Check interval in minutes (min: 5) |
 
 **Environment variables:**
 
@@ -764,17 +769,17 @@ The subagent has access to tools (message, web_search, etc.) and can communicate
 > [!NOTE]
 > Groq provides free voice transcription via Whisper. If configured, Telegram voice messages will be automatically transcribed.
 
-| Provider                   | Purpose                                 | Get API Key                                            |
-| -------------------------- | --------------------------------------- | ------------------------------------------------------ |
-| `gemini`                   | LLM (Gemini direct)                     | [aistudio.google.com](https://aistudio.google.com)     |
-| `zhipu`                    | LLM (Zhipu direct)                      | [bigmodel.cn](bigmodel.cn)                             |
-| `openrouter(To be tested)` | LLM (recommended, access to all models) | [openrouter.ai](https://openrouter.ai)                 |
-| `anthropic(To be tested)`  | LLM (Claude direct)                     | [console.anthropic.com](https://console.anthropic.com) |
-| `openai(To be tested)`     | LLM (GPT direct)                        | [platform.openai.com](https://platform.openai.com)     |
-| `deepseek(To be tested)`   | LLM (DeepSeek direct)                   | [platform.deepseek.com](https://platform.deepseek.com) |
+| Provider                   | Purpose                                 | Get API Key                                                          |
+| -------------------------- | --------------------------------------- | -------------------------------------------------------------------- |
+| `gemini`                   | LLM (Gemini direct)                     | [aistudio.google.com](https://aistudio.google.com)                   |
+| `zhipu`                    | LLM (Zhipu direct)                      | [bigmodel.cn](https://bigmodel.cn)                                   |
+| `openrouter(To be tested)` | LLM (recommended, access to all models) | [openrouter.ai](https://openrouter.ai)                               |
+| `anthropic(To be tested)`  | LLM (Claude direct)                     | [console.anthropic.com](https://console.anthropic.com)               |
+| `openai(To be tested)`     | LLM (GPT direct)                        | [platform.openai.com](https://platform.openai.com)                   |
+| `deepseek(To be tested)`   | LLM (DeepSeek direct)                   | [platform.deepseek.com](https://platform.deepseek.com)               |
 | `qwen`                     | LLM (Qwen direct)                       | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
-| `groq`                     | LLM + **Voice transcription** (Whisper) | [console.groq.com](https://console.groq.com)           |
-| `cerebras`                 | LLM (Cerebras direct)                   | [cerebras.ai](https://cerebras.ai)                     |
+| `groq`                     | LLM + **Voice transcription** (Whisper) | [console.groq.com](https://console.groq.com)                         |
+| `cerebras`                 | LLM (Cerebras direct)                   | [cerebras.ai](https://cerebras.ai)                                   |
 
 ### Model Configuration (model_list)
 
@@ -789,25 +794,25 @@ This design also enables **multi-agent support** with flexible provider selectio
 
 #### 📋 All Supported Vendors
 
-| Vendor | `model` Prefix | Default API Base | Protocol | API Key |
-|--------|----------------|------------------|----------|---------|
-| **OpenAI** | `openai/` | `https://api.openai.com/v1` | OpenAI | [Get Key](https://platform.openai.com) |
-| **Anthropic** | `anthropic/` | `https://api.anthropic.com/v1` | Anthropic | [Get Key](https://console.anthropic.com) |
-| **智谱 AI (GLM)** | `zhipu/` | `https://open.bigmodel.cn/api/paas/v4` | OpenAI | [Get Key](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
-| **DeepSeek** | `deepseek/` | `https://api.deepseek.com/v1` | OpenAI | [Get Key](https://platform.deepseek.com) |
-| **Google Gemini** | `gemini/` | `https://generativelanguage.googleapis.com/v1beta` | OpenAI | [Get Key](https://aistudio.google.com/api-keys) |
-| **Groq** | `groq/` | `https://api.groq.com/openai/v1` | OpenAI | [Get Key](https://console.groq.com) |
-| **Moonshot** | `moonshot/` | `https://api.moonshot.cn/v1` | OpenAI | [Get Key](https://platform.moonshot.cn) |
-| **通义千问 (Qwen)** | `qwen/` | `https://dashscope.aliyuncs.com/compatible-mode/v1` | OpenAI | [Get Key](https://dashscope.console.aliyun.com) |
-| **NVIDIA** | `nvidia/` | `https://integrate.api.nvidia.com/v1` | OpenAI | [Get Key](https://build.nvidia.com) |
-| **Ollama** | `ollama/` | `http://localhost:11434/v1` | OpenAI | Local (no key needed) |
-| **OpenRouter** | `openrouter/` | `https://openrouter.ai/api/v1` | OpenAI | [Get Key](https://openrouter.ai/keys) |
-| **VLLM** | `vllm/` | `http://localhost:8000/v1` | OpenAI | Local |
-| **Cerebras** | `cerebras/` | `https://api.cerebras.ai/v1` | OpenAI | [Get Key](https://cerebras.ai) |
-| **火山引擎** | `volcengine/` | `https://ark.cn-beijing.volces.com/api/v3` | OpenAI | [Get Key](https://console.volcengine.com) |
-| **神算云** | `shengsuanyun/` | `https://router.shengsuanyun.com/api/v1` | OpenAI | - |
-| **Antigravity** | `antigravity/` | Google Cloud | Custom | OAuth only |
-| **GitHub Copilot** | `github-copilot/` | `localhost:4321` | gRPC | - |
+| Vendor              | `model` Prefix    | Default API Base                                    | Protocol  | API Key                                                          |
+| ------------------- | ----------------- | --------------------------------------------------- | --------- | ---------------------------------------------------------------- |
+| **OpenAI**          | `openai/`         | `https://api.openai.com/v1`                         | OpenAI    | [Get Key](https://platform.openai.com)                           |
+| **Anthropic**       | `anthropic/`      | `https://api.anthropic.com/v1`                      | Anthropic | [Get Key](https://console.anthropic.com)                         |
+| **智谱 AI (GLM)**   | `zhipu/`          | `https://open.bigmodel.cn/api/paas/v4`              | OpenAI    | [Get Key](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
+| **DeepSeek**        | `deepseek/`       | `https://api.deepseek.com/v1`                       | OpenAI    | [Get Key](https://platform.deepseek.com)                         |
+| **Google Gemini**   | `gemini/`         | `https://generativelanguage.googleapis.com/v1beta`  | OpenAI    | [Get Key](https://aistudio.google.com/api-keys)                  |
+| **Groq**            | `groq/`           | `https://api.groq.com/openai/v1`                    | OpenAI    | [Get Key](https://console.groq.com)                              |
+| **Moonshot**        | `moonshot/`       | `https://api.moonshot.cn/v1`                        | OpenAI    | [Get Key](https://platform.moonshot.cn)                          |
+| **通义千问 (Qwen)** | `qwen/`           | `https://dashscope.aliyuncs.com/compatible-mode/v1` | OpenAI    | [Get Key](https://dashscope.console.aliyun.com)                  |
+| **NVIDIA**          | `nvidia/`         | `https://integrate.api.nvidia.com/v1`               | OpenAI    | [Get Key](https://build.nvidia.com)                              |
+| **Ollama**          | `ollama/`         | `http://localhost:11434/v1`                         | OpenAI    | Local (no key needed)                                            |
+| **OpenRouter**      | `openrouter/`     | `https://openrouter.ai/api/v1`                      | OpenAI    | [Get Key](https://openrouter.ai/keys)                            |
+| **VLLM**            | `vllm/`           | `http://localhost:8000/v1`                          | OpenAI    | Local                                                            |
+| **Cerebras**        | `cerebras/`       | `https://api.cerebras.ai/v1`                        | OpenAI    | [Get Key](https://cerebras.ai)                                   |
+| **火山引擎**        | `volcengine/`     | `https://ark.cn-beijing.volces.com/api/v3`          | OpenAI    | [Get Key](https://console.volcengine.com)                        |
+| **神算云**          | `shengsuanyun/`   | `https://router.shengsuanyun.com/api/v1`            | OpenAI    | -                                                                |
+| **Antigravity**     | `antigravity/`    | Google Cloud                                        | Custom    | OAuth only                                                       |
+| **GitHub Copilot**  | `github-copilot/` | `localhost:4321`                                    | gRPC      | -                                                                |
 
 #### Basic Configuration
 
@@ -841,6 +846,7 @@ This design also enables **multi-agent support** with flexible provider selectio
 #### Vendor-Specific Examples
 
 **OpenAI**
+
 ```json
 {
   "model_name": "gpt-5.2",
@@ -850,6 +856,7 @@ This design also enables **multi-agent support** with flexible provider selectio
 ```
 
 **智谱 AI (GLM)**
+
 ```json
 {
   "model_name": "glm-4.7",
@@ -859,6 +866,7 @@ This design also enables **multi-agent support** with flexible provider selectio
 ```
 
 **DeepSeek**
+
 ```json
 {
   "model_name": "deepseek-chat",
@@ -868,6 +876,7 @@ This design also enables **multi-agent support** with flexible provider selectio
 ```
 
 **Anthropic (with API key)**
+
 ```json
 {
   "model_name": "claude-sonnet-4.6",
@@ -875,9 +884,11 @@ This design also enables **multi-agent support** with flexible provider selectio
   "api_key": "sk-ant-your-key"
 }
 ```
+
 > Run `picoclaw auth login --provider anthropic` to paste your API token.
 
 **Ollama (local)**
+
 ```json
 {
   "model_name": "llama3",
@@ -886,6 +897,7 @@ This design also enables **multi-agent support** with flexible provider selectio
 ```
 
 **Custom Proxy/API**
+
 ```json
 {
   "model_name": "my-custom-model",
@@ -923,6 +935,7 @@ Configure multiple endpoints for the same model name—PicoClaw will automatical
 The old `providers` configuration is **deprecated** but still supported for backward compatibility.
 
 **Old Config (deprecated):**
+
 ```json
 {
   "providers": {
@@ -941,6 +954,7 @@ The old `providers` configuration is **deprecated** but still supported for back
 ```
 
 **New Config (recommended):**
+
 ```json
 {
   "model_list": [
@@ -1105,13 +1119,13 @@ Jobs are stored in `~/.picoclaw/workspace/cron/` and processed automatically.
 
 PRs welcome! The codebase is intentionally small and readable. 🤗
 
-Roadmap coming soon...
+See our full [Community Roadmap](https://github.com/sipeed/picoclaw/blob/main/ROADMAP.md).
 
-Developer group building, Entry Requirement: At least 1 Merged PR.
+Developer group building, join after your first merged PR!
 
 User Groups:
 
-discord:  <https://discord.gg/V4sAZ9XWpN>
+discord: <https://discord.gg/V4sAZ9XWpN>
 
 <img src="assets/wechat.png" alt="PicoClaw" width="512">
 

From cb0c8703fb9d5ce373bc0c4f770177ba66508b25 Mon Sep 17 00:00:00 2001
From: King Tai <109292982+CrisisAlpha@users.noreply.github.com>
Date: Sun, 22 Feb 2026 18:40:59 +0800
Subject: [PATCH 15/52] test(tools,utils): add ToolRegistry unit tests and fix
 Truncate panic on negative maxLen (#517)

Add comprehensive unit tests for the ToolRegistry covering registration,
lookup, execution, context injection, async callbacks, schema generation,
provider definition conversion, and concurrent access.

Fix a defensive edge case in Truncate where a negative maxLen would cause
a slice bounds panic, and add table-driven tests covering boundary
conditions, zero/negative lengths, and Unicode handling.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 pkg/tools/registry_test.go | 350 +++++++++++++++++++++++++++++++++++++
 pkg/utils/string.go        |   3 +
 pkg/utils/string_test.go   | 106 +++++++++++
 3 files changed, 459 insertions(+)
 create mode 100644 pkg/tools/registry_test.go
 create mode 100644 pkg/utils/string_test.go

diff --git a/pkg/tools/registry_test.go b/pkg/tools/registry_test.go
new file mode 100644
index 000000000..33978e543
--- /dev/null
+++ b/pkg/tools/registry_test.go
@@ -0,0 +1,350 @@
+package tools
+
+import (
+	"context"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/providers"
+)
+
+// --- mock types ---
+
+type mockRegistryTool struct {
+	name   string
+	desc   string
+	params map[string]interface{}
+	result *ToolResult
+}
+
+func (m *mockRegistryTool) Name() string                       { return m.name }
+func (m *mockRegistryTool) Description() string                { return m.desc }
+func (m *mockRegistryTool) Parameters() map[string]interface{} { return m.params }
+func (m *mockRegistryTool) Execute(_ context.Context, _ map[string]interface{}) *ToolResult {
+	return m.result
+}
+
+type mockCtxTool struct {
+	mockRegistryTool
+	channel string
+	chatID  string
+}
+
+func (m *mockCtxTool) SetContext(channel, chatID string) {
+	m.channel = channel
+	m.chatID = chatID
+}
+
+type mockAsyncRegistryTool struct {
+	mockRegistryTool
+	cb AsyncCallback
+}
+
+func (m *mockAsyncRegistryTool) SetCallback(cb AsyncCallback) {
+	m.cb = cb
+}
+
+// --- helpers ---
+
+func newMockTool(name, desc string) *mockRegistryTool {
+	return &mockRegistryTool{
+		name:   name,
+		desc:   desc,
+		params: map[string]interface{}{"type": "object"},
+		result: SilentResult("ok"),
+	}
+}
+
+// --- tests ---
+
+func TestNewToolRegistry(t *testing.T) {
+	r := NewToolRegistry()
+	if r.Count() != 0 {
+		t.Errorf("expected empty registry, got count %d", r.Count())
+	}
+	if len(r.List()) != 0 {
+		t.Errorf("expected empty list, got %v", r.List())
+	}
+}
+
+func TestToolRegistry_RegisterAndGet(t *testing.T) {
+	r := NewToolRegistry()
+	tool := newMockTool("echo", "echoes input")
+	r.Register(tool)
+
+	got, ok := r.Get("echo")
+	if !ok {
+		t.Fatal("expected to find registered tool")
+	}
+	if got.Name() != "echo" {
+		t.Errorf("expected name 'echo', got %q", got.Name())
+	}
+}
+
+func TestToolRegistry_Get_NotFound(t *testing.T) {
+	r := NewToolRegistry()
+	_, ok := r.Get("nonexistent")
+	if ok {
+		t.Error("expected ok=false for unregistered tool")
+	}
+}
+
+func TestToolRegistry_RegisterOverwrite(t *testing.T) {
+	r := NewToolRegistry()
+	r.Register(newMockTool("dup", "first"))
+	r.Register(newMockTool("dup", "second"))
+
+	if r.Count() != 1 {
+		t.Errorf("expected count 1 after overwrite, got %d", r.Count())
+	}
+	tool, _ := r.Get("dup")
+	if tool.Description() != "second" {
+		t.Errorf("expected overwritten description 'second', got %q", tool.Description())
+	}
+}
+
+func TestToolRegistry_Execute_Success(t *testing.T) {
+	r := NewToolRegistry()
+	r.Register(&mockRegistryTool{
+		name:   "greet",
+		desc:   "says hello",
+		params: map[string]interface{}{},
+		result: SilentResult("hello"),
+	})
+
+	result := r.Execute(context.Background(), "greet", nil)
+	if result.IsError {
+		t.Errorf("expected success, got error: %s", result.ForLLM)
+	}
+	if result.ForLLM != "hello" {
+		t.Errorf("expected ForLLM 'hello', got %q", result.ForLLM)
+	}
+}
+
+func TestToolRegistry_Execute_NotFound(t *testing.T) {
+	r := NewToolRegistry()
+	result := r.Execute(context.Background(), "missing", nil)
+	if !result.IsError {
+		t.Error("expected error for missing tool")
+	}
+	if !strings.Contains(result.ForLLM, "not found") {
+		t.Errorf("expected 'not found' in error, got %q", result.ForLLM)
+	}
+	if result.Err == nil {
+		t.Error("expected Err to be set via WithError")
+	}
+}
+
+func TestToolRegistry_ExecuteWithContext_ContextualTool(t *testing.T) {
+	r := NewToolRegistry()
+	ct := &mockCtxTool{
+		mockRegistryTool: *newMockTool("ctx_tool", "needs context"),
+	}
+	r.Register(ct)
+
+	r.ExecuteWithContext(context.Background(), "ctx_tool", nil, "telegram", "chat-42", nil)
+
+	if ct.channel != "telegram" {
+		t.Errorf("expected channel 'telegram', got %q", ct.channel)
+	}
+	if ct.chatID != "chat-42" {
+		t.Errorf("expected chatID 'chat-42', got %q", ct.chatID)
+	}
+}
+
+func TestToolRegistry_ExecuteWithContext_SkipsEmptyContext(t *testing.T) {
+	r := NewToolRegistry()
+	ct := &mockCtxTool{
+		mockRegistryTool: *newMockTool("ctx_tool", "needs context"),
+	}
+	r.Register(ct)
+
+	r.ExecuteWithContext(context.Background(), "ctx_tool", nil, "", "", nil)
+
+	if ct.channel != "" || ct.chatID != "" {
+		t.Error("SetContext should not be called with empty channel/chatID")
+	}
+}
+
+func TestToolRegistry_ExecuteWithContext_AsyncCallback(t *testing.T) {
+	r := NewToolRegistry()
+	at := &mockAsyncRegistryTool{
+		mockRegistryTool: *newMockTool("async_tool", "async work"),
+	}
+	at.result = AsyncResult("started")
+	r.Register(at)
+
+	called := false
+	cb := func(_ context.Context, _ *ToolResult) { called = true }
+
+	result := r.ExecuteWithContext(context.Background(), "async_tool", nil, "", "", cb)
+	if at.cb == nil {
+		t.Error("expected SetCallback to have been called")
+	}
+	if !result.Async {
+		t.Error("expected async result")
+	}
+
+	at.cb(context.Background(), SilentResult("done"))
+	if !called {
+		t.Error("expected callback to be invoked")
+	}
+}
+
+func TestToolRegistry_GetDefinitions(t *testing.T) {
+	r := NewToolRegistry()
+	r.Register(newMockTool("alpha", "tool A"))
+
+	defs := r.GetDefinitions()
+	if len(defs) != 1 {
+		t.Fatalf("expected 1 definition, got %d", len(defs))
+	}
+	if defs[0]["type"] != "function" {
+		t.Errorf("expected type 'function', got %v", defs[0]["type"])
+	}
+	fn, ok := defs[0]["function"].(map[string]interface{})
+	if !ok {
+		t.Fatal("expected 'function' key to be a map")
+	}
+	if fn["name"] != "alpha" {
+		t.Errorf("expected name 'alpha', got %v", fn["name"])
+	}
+	if fn["description"] != "tool A" {
+		t.Errorf("expected description 'tool A', got %v", fn["description"])
+	}
+}
+
+func TestToolRegistry_ToProviderDefs(t *testing.T) {
+	r := NewToolRegistry()
+	params := map[string]interface{}{"type": "object", "properties": map[string]interface{}{}}
+	r.Register(&mockRegistryTool{
+		name:   "beta",
+		desc:   "tool B",
+		params: params,
+		result: SilentResult("ok"),
+	})
+
+	defs := r.ToProviderDefs()
+	if len(defs) != 1 {
+		t.Fatalf("expected 1 provider def, got %d", len(defs))
+	}
+
+	want := providers.ToolDefinition{
+		Type: "function",
+		Function: providers.ToolFunctionDefinition{
+			Name:        "beta",
+			Description: "tool B",
+			Parameters:  params,
+		},
+	}
+	got := defs[0]
+	if got.Type != want.Type {
+		t.Errorf("Type: want %q, got %q", want.Type, got.Type)
+	}
+	if got.Function.Name != want.Function.Name {
+		t.Errorf("Name: want %q, got %q", want.Function.Name, got.Function.Name)
+	}
+	if got.Function.Description != want.Function.Description {
+		t.Errorf("Description: want %q, got %q", want.Function.Description, got.Function.Description)
+	}
+}
+
+func TestToolRegistry_List(t *testing.T) {
+	r := NewToolRegistry()
+	r.Register(newMockTool("x", ""))
+	r.Register(newMockTool("y", ""))
+
+	names := r.List()
+	if len(names) != 2 {
+		t.Fatalf("expected 2 names, got %d", len(names))
+	}
+
+	nameSet := map[string]bool{}
+	for _, n := range names {
+		nameSet[n] = true
+	}
+	if !nameSet["x"] || !nameSet["y"] {
+		t.Errorf("expected names {x, y}, got %v", names)
+	}
+}
+
+func TestToolRegistry_Count(t *testing.T) {
+	r := NewToolRegistry()
+	if r.Count() != 0 {
+		t.Errorf("expected 0, got %d", r.Count())
+	}
+
+	r.Register(newMockTool("a", ""))
+	r.Register(newMockTool("b", ""))
+	if r.Count() != 2 {
+		t.Errorf("expected 2, got %d", r.Count())
+	}
+
+	r.Register(newMockTool("a", "replaced"))
+	if r.Count() != 2 {
+		t.Errorf("expected 2 after overwrite, got %d", r.Count())
+	}
+}
+
+func TestToolRegistry_GetSummaries(t *testing.T) {
+	r := NewToolRegistry()
+	r.Register(newMockTool("read_file", "Reads a file"))
+
+	summaries := r.GetSummaries()
+	if len(summaries) != 1 {
+		t.Fatalf("expected 1 summary, got %d", len(summaries))
+	}
+	if !strings.Contains(summaries[0], "`read_file`") {
+		t.Errorf("expected backtick-quoted name in summary, got %q", summaries[0])
+	}
+	if !strings.Contains(summaries[0], "Reads a file") {
+		t.Errorf("expected description in summary, got %q", summaries[0])
+	}
+}
+
+func TestToolToSchema(t *testing.T) {
+	tool := newMockTool("demo", "demo tool")
+	schema := ToolToSchema(tool)
+
+	if schema["type"] != "function" {
+		t.Errorf("expected type 'function', got %v", schema["type"])
+	}
+	fn, ok := schema["function"].(map[string]interface{})
+	if !ok {
+		t.Fatal("expected 'function' to be a map")
+	}
+	if fn["name"] != "demo" {
+		t.Errorf("expected name 'demo', got %v", fn["name"])
+	}
+	if fn["description"] != "demo tool" {
+		t.Errorf("expected description 'demo tool', got %v", fn["description"])
+	}
+	if fn["parameters"] == nil {
+		t.Error("expected parameters to be set")
+	}
+}
+
+func TestToolRegistry_ConcurrentAccess(t *testing.T) {
+	r := NewToolRegistry()
+	var wg sync.WaitGroup
+
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			name := string(rune('A' + n%26))
+			r.Register(newMockTool(name, "concurrent"))
+			r.Get(name)
+			r.Count()
+			r.List()
+			r.GetDefinitions()
+		}(i)
+	}
+
+	wg.Wait()
+
+	if r.Count() == 0 {
+		t.Error("expected tools to be registered after concurrent access")
+	}
+}
diff --git a/pkg/utils/string.go b/pkg/utils/string.go
index 7a6aa37cc..62d9beee0 100644
--- a/pkg/utils/string.go
+++ b/pkg/utils/string.go
@@ -4,6 +4,9 @@ package utils
 // Handles multi-byte Unicode characters properly.
 // If the string is truncated, "..." is appended to indicate truncation.
 func Truncate(s string, maxLen int) string {
+	if maxLen <= 0 {
+		return ""
+	}
 	runes := []rune(s)
 	if len(runes) <= maxLen {
 		return s
diff --git a/pkg/utils/string_test.go b/pkg/utils/string_test.go
new file mode 100644
index 000000000..a44ead228
--- /dev/null
+++ b/pkg/utils/string_test.go
@@ -0,0 +1,106 @@
+package utils
+
+import "testing"
+
+func TestTruncate(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  string
+		maxLen int
+		want   string
+	}{
+		{
+			name:   "short string unchanged",
+			input:  "hi",
+			maxLen: 10,
+			want:   "hi",
+		},
+		{
+			name:   "exact length unchanged",
+			input:  "hello",
+			maxLen: 5,
+			want:   "hello",
+		},
+		{
+			name:   "long string truncated with ellipsis",
+			input:  "hello world",
+			maxLen: 8,
+			want:   "hello...",
+		},
+		{
+			name:   "maxLen equals 4 leaves 1 char plus ellipsis",
+			input:  "abcdef",
+			maxLen: 4,
+			want:   "a...",
+		},
+		{
+			name:   "maxLen 3 returns first 3 chars without ellipsis",
+			input:  "abcdef",
+			maxLen: 3,
+			want:   "abc",
+		},
+		{
+			name:   "maxLen 2 returns first 2 chars",
+			input:  "abcdef",
+			maxLen: 2,
+			want:   "ab",
+		},
+		{
+			name:   "maxLen 1 returns first char",
+			input:  "abcdef",
+			maxLen: 1,
+			want:   "a",
+		},
+		{
+			name:   "maxLen 0 returns empty",
+			input:  "hello",
+			maxLen: 0,
+			want:   "",
+		},
+		{
+			name:   "negative maxLen returns empty",
+			input:  "hello",
+			maxLen: -1,
+			want:   "",
+		},
+		{
+			name:   "empty string unchanged",
+			input:  "",
+			maxLen: 5,
+			want:   "",
+		},
+		{
+			name:   "empty string with zero maxLen",
+			input:  "",
+			maxLen: 0,
+			want:   "",
+		},
+		{
+			name:   "unicode truncated correctly",
+			input:  "\U0001f600\U0001f601\U0001f602\U0001f603\U0001f604",
+			maxLen: 4,
+			want:   "\U0001f600...",
+		},
+		{
+			name:   "unicode short enough",
+			input:  "\u00e9\u00e8",
+			maxLen: 5,
+			want:   "\u00e9\u00e8",
+		},
+		{
+			name:   "mixed ascii and unicode",
+			input:  "Go\U0001f680\U0001f525\U0001f4a5\U0001f30d",
+			maxLen: 5,
+			want:   "Go...",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Truncate(tt.input, tt.maxLen)
+			if got != tt.want {
+				t.Errorf("Truncate(%q, %d) = %q, want %q", tt.input, tt.maxLen, got, tt.want)
+			}
+		})
+	}
+}

From c6865fe852f4e163767b78b6df72a06b5fdc6204 Mon Sep 17 00:00:00 2001
From: Vidish <57653368+ulolol@users.noreply.github.com>
Date: Sun, 22 Feb 2026 22:00:14 +0530
Subject: [PATCH 16/52] feat: integrate Tavily search (#340)

* feat: integrate Tavily search

* fix: set include_raw_content to false in Tavily search as wealready get relevant data inside content

* refactor: update Go type declarations to `any`, apply formatting fixes.
---
 README.ja.md               | 29 ++++++++++--
 README.md                  |  9 +++-
 README.zh.md               | 27 ++++++-----
 pkg/config/config.go       |  8 ++++
 pkg/tools/registry_test.go | 20 ++++----
 pkg/tools/web.go           | 97 +++++++++++++++++++++++++++++++++++++-
 pkg/tools/web_test.go      | 72 ++++++++++++++++++++++++++++
 7 files changed, 232 insertions(+), 30 deletions(-)

diff --git a/README.ja.md b/README.ja.md
index bb0bdfb28..3506c77c2 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -162,7 +162,7 @@ docker compose --profile gateway up -d
 > [!TIP]
 > `~/.picoclaw/config.json` に API キーを設定してください。
 > API キーの取得先: [OpenRouter](https://openrouter.ai/keys) (LLM) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) (LLM)
-> Web 検索は **任意** です - 無料の [Brave Search API](https://brave.com/search/api) (月 2000 クエリ無料)
+> Web 検索は **任意** です - 無料の [Tavily API](https://tavily.com) (月 1000 クエリ無料) または [Brave Search API](https://brave.com/search/api) (月 2000 クエリ無料)
 
 **1. 初期化**
 
@@ -193,14 +193,34 @@ picoclaw onboard
       "token": "YOUR_TELEGRAM_BOT_TOKEN",
       "allow_from": []
     }
+  },
+  "tools": {
+    "web": {
+      "search": {
+        "api_key": "YOUR_BRAVE_API_KEY",
+        "max_results": 5
+      },
+      "tavily": {
+        "enabled": false,
+        "api_key": "YOUR_TAVILY_API_KEY",
+        "max_results": 5
+      }
+    },
+    "cron": {
+      "exec_timeout_minutes": 5
+    }
+  },
+  "heartbeat": {
+    "enabled": true,
+    "interval": 30
   }
 }
 ```
 
 **3. API キーの取得**
 
-- **LLM プロバイダー**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys) · [Qwen](https://dashscope.console.aliyun.com)
-- **Web 検索**（任意）: [Brave Search](https://brave.com/search/api) - 無料枠あり（月 2000 リクエスト）
+- **LLM プロバイダー**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
+- **Web 検索**（任意）: [Tavily](https://tavily.com) - AI エージェント向けに最適化 (月 1000 リクエスト) · [Brave Search](https://brave.com/search/api) - 無料枠あり（月 2000 リクエスト）
 
 > **注意**: 完全な設定テンプレートは `config.example.json` を参照してください。
 
@@ -985,7 +1005,7 @@ Discord: https://discord.gg/V4sAZ9XWpN
 検索 API キーをまだ設定していない場合、これは正常です。PicoClaw は手動検索用の便利なリンクを提供します。
 
 Web 検索を有効にするには：
-1. [https://brave.com/search/api](https://brave.com/search/api) で無料の API キーを取得（月 2000 クエリ無料）
+1. [https://tavily.com](https://tavily.com) (月 1000 クエリ無料) または [https://brave.com/search/api](https://brave.com/search/api) で無料の API キーを取得（月 2000 クエリ無料）
 2. `~/.picoclaw/config.json` に追加：
    ```json
    {
@@ -1023,5 +1043,6 @@ Web 検索を有効にするには：
 | **Zhipu** | 月 200K トークン | 中国ユーザー向け最適 |
 | **Qwen** | 無料枠あり | 通義千問 (Qwen) |
 | **Brave Search** | 月 2000 クエリ | Web 検索機能 |
+| **Tavily** | 月 1000 クエリ | AI エージェント検索最適化 |
 | **Groq** | 無料枠あり | 高速推論（Llama, Mixtral） |
 | **Cerebras** | 無料枠あり | 高速推論（Llama, Qwen など） |
diff --git a/README.md b/README.md
index de6fd87ea..825f57340 100644
--- a/README.md
+++ b/README.md
@@ -200,7 +200,7 @@ docker compose --profile gateway up -d
 > [!TIP]
 > Set your API key in `~/.picoclaw/config.json`.
 > Get API keys: [OpenRouter](https://openrouter.ai/keys) (LLM) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) (LLM)
-> Web search is **optional** - get free [Brave Search API](https://brave.com/search/api) (2000 free queries/month) or use built-in auto fallback.
+> Web Search is **optional** - get free [Tavily API](https://tavily.com) (1000 free queries/month) or [Brave Search API](https://brave.com/search/api) (2000 free queries/month) or use built-in auto fallback.
 
 **1. Initialize**
 
@@ -240,6 +240,11 @@ picoclaw onboard
         "api_key": "YOUR_BRAVE_API_KEY",
         "max_results": 5
       },
+      "tavily": {
+        "enabled": false,
+        "api_key": "YOUR_TAVILY_API_KEY",
+        "max_results": 5
+      },
       "duckduckgo": {
         "enabled": true,
         "max_results": 5
@@ -254,7 +259,7 @@ picoclaw onboard
 **3. Get API Keys**
 
 * **LLM Provider**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
-* **Web Search** (optional): [Brave Search](https://brave.com/search/api) - Free tier available (2000 requests/month)
+* **Web Search** (optional): [Tavily](https://tavily.com) - Optimized for AI Agents (1000 requests/month) · [Brave Search](https://brave.com/search/api) - Free tier available (2000 requests/month)
 
 > **Note**: See `config.example.json` for a complete configuration template.
 
diff --git a/README.zh.md b/README.zh.md
index 4d739c5eb..fd188567d 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -205,7 +205,7 @@ docker compose --profile gateway up -d
 > [!TIP]
 > 在 `~/.picoclaw/config.json` 中设置您的 API Key。
 > 获取 API Key: [OpenRouter](https://openrouter.ai/keys) (LLM) · [Zhipu (智谱)](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) (LLM)
-> 网络搜索是 **可选的** - 获取免费的 [Brave Search API](https://brave.com/search/api) (每月 2000 次免费查询)
+> 网络搜索是 **可选的** - 获取免费的 [Tavily API](https://tavily.com) (每月 1000 次免费查询) 或 [Brave Search API](https://brave.com/search/api) (每月 2000 次免费查询)
 
 **1. 初始化 (Initialize)**
 
@@ -246,8 +246,9 @@ picoclaw onboard
         "api_key": "YOUR_BRAVE_API_KEY",
         "max_results": 5
       },
-      "duckduckgo": {
-        "enabled": true,
+      "tavily": {
+        "enabled": false,
+        "api_key": "YOUR_TAVILY_API_KEY",
         "max_results": 5
       }
     },
@@ -262,8 +263,8 @@ picoclaw onboard
 
 **3. 获取 API Key**
 
-- **LLM 提供商**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
-- **网络搜索** (可选): [Brave Search](https://brave.com/search/api) - 提供免费层级 (2000 请求/月)
+* **LLM 提供商**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
+* **网络搜索** (可选): [Tavily](https://tavily.com) - 专为 AI Agent 优化 (1000 请求/月) · [Brave Search](https://brave.com/search/api) - 提供免费层级 (2000 请求/月)
 
 > **注意**: 完整的配置模板请参考 `config.example.json`。
 
@@ -771,7 +772,7 @@ Discord: [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
 
 启用网络搜索：
 
-1. 在 [https://brave.com/search/api](https://brave.com/search/api) 获取免费 API Key (每月 2000 次免费查询)
+1. 在 [https://tavily.com](https://tavily.com) (1000 次免费) 或 [https://brave.com/search/api](https://brave.com/search/api) 获取免费 API Key (2000 次免费)
 2. 添加到 `~/.picoclaw/config.json`:
 
 ```json
@@ -804,10 +805,10 @@ Discord: [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
 
 ## 📝 API Key 对比
 
-| 服务             | 免费层级       | 适用场景                      |
-| ---------------- | -------------- | ----------------------------- |
-| **OpenRouter**   | 200K tokens/月 | 多模型聚合 (Claude, GPT-4 等) |
-| **智谱 (Zhipu)** | 200K tokens/月 | 最适合中国用户                |
-| **Brave Search** | 2000 次查询/月 | 网络搜索功能                  |
-| **Groq**         | 提供免费层级   | 极速推理 (Llama, Mixtral)     |
-| **Cerebras**     | 提供免费层级   | 极速推理 (Llama, Qwen 等)     |
+| 服务 | 免费层级 | 适用场景 |
+| --- | --- | --- |
+| **OpenRouter** | 200K tokens/月 | 多模型聚合 (Claude, GPT-4 等) |
+| **智谱 (Zhipu)** | 200K tokens/月 | 最适合中国用户 |
+| **Brave Search** | 2000 次查询/月 | 网络搜索功能 |
+| **Tavily** | 1000 次查询/月 | AI Agent 搜索优化 |
+| **Groq** | 提供免费层级 | 极速推理 (Llama, Mixtral) |
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 20556011a..036021e49 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -418,6 +418,13 @@ type BraveConfig struct {
 	MaxResults int    `json:"max_results" env:"PICOCLAW_TOOLS_WEB_BRAVE_MAX_RESULTS"`
 }
 
+type TavilyConfig struct {
+	Enabled    bool   `json:"enabled"     env:"PICOCLAW_TOOLS_WEB_TAVILY_ENABLED"`
+	APIKey     string `json:"api_key"     env:"PICOCLAW_TOOLS_WEB_TAVILY_API_KEY"`
+	BaseURL    string `json:"base_url"    env:"PICOCLAW_TOOLS_WEB_TAVILY_BASE_URL"`
+	MaxResults int    `json:"max_results" env:"PICOCLAW_TOOLS_WEB_TAVILY_MAX_RESULTS"`
+}
+
 type DuckDuckGoConfig struct {
 	Enabled    bool `json:"enabled"     env:"PICOCLAW_TOOLS_WEB_DUCKDUCKGO_ENABLED"`
 	MaxResults int  `json:"max_results" env:"PICOCLAW_TOOLS_WEB_DUCKDUCKGO_MAX_RESULTS"`
@@ -431,6 +438,7 @@ type PerplexityConfig struct {
 
 type WebToolsConfig struct {
 	Brave      BraveConfig      `json:"brave"`
+	Tavily     TavilyConfig     `json:"tavily"`
 	DuckDuckGo DuckDuckGoConfig `json:"duckduckgo"`
 	Perplexity PerplexityConfig `json:"perplexity"`
 }
diff --git a/pkg/tools/registry_test.go b/pkg/tools/registry_test.go
index 33978e543..8ae13b20c 100644
--- a/pkg/tools/registry_test.go
+++ b/pkg/tools/registry_test.go
@@ -14,14 +14,14 @@ import (
 type mockRegistryTool struct {
 	name   string
 	desc   string
-	params map[string]interface{}
+	params map[string]any
 	result *ToolResult
 }
 
-func (m *mockRegistryTool) Name() string                       { return m.name }
-func (m *mockRegistryTool) Description() string                { return m.desc }
-func (m *mockRegistryTool) Parameters() map[string]interface{} { return m.params }
-func (m *mockRegistryTool) Execute(_ context.Context, _ map[string]interface{}) *ToolResult {
+func (m *mockRegistryTool) Name() string               { return m.name }
+func (m *mockRegistryTool) Description() string        { return m.desc }
+func (m *mockRegistryTool) Parameters() map[string]any { return m.params }
+func (m *mockRegistryTool) Execute(_ context.Context, _ map[string]any) *ToolResult {
 	return m.result
 }
 
@@ -51,7 +51,7 @@ func newMockTool(name, desc string) *mockRegistryTool {
 	return &mockRegistryTool{
 		name:   name,
 		desc:   desc,
-		params: map[string]interface{}{"type": "object"},
+		params: map[string]any{"type": "object"},
 		result: SilentResult("ok"),
 	}
 }
@@ -109,7 +109,7 @@ func TestToolRegistry_Execute_Success(t *testing.T) {
 	r.Register(&mockRegistryTool{
 		name:   "greet",
 		desc:   "says hello",
-		params: map[string]interface{}{},
+		params: map[string]any{},
 		result: SilentResult("hello"),
 	})
 
@@ -203,7 +203,7 @@ func TestToolRegistry_GetDefinitions(t *testing.T) {
 	if defs[0]["type"] != "function" {
 		t.Errorf("expected type 'function', got %v", defs[0]["type"])
 	}
-	fn, ok := defs[0]["function"].(map[string]interface{})
+	fn, ok := defs[0]["function"].(map[string]any)
 	if !ok {
 		t.Fatal("expected 'function' key to be a map")
 	}
@@ -217,7 +217,7 @@ func TestToolRegistry_GetDefinitions(t *testing.T) {
 
 func TestToolRegistry_ToProviderDefs(t *testing.T) {
 	r := NewToolRegistry()
-	params := map[string]interface{}{"type": "object", "properties": map[string]interface{}{}}
+	params := map[string]any{"type": "object", "properties": map[string]any{}}
 	r.Register(&mockRegistryTool{
 		name:   "beta",
 		desc:   "tool B",
@@ -310,7 +310,7 @@ func TestToolToSchema(t *testing.T) {
 	if schema["type"] != "function" {
 		t.Errorf("expected type 'function', got %v", schema["type"])
 	}
-	fn, ok := schema["function"].(map[string]interface{})
+	fn, ok := schema["function"].(map[string]any)
 	if !ok {
 		t.Fatal("expected 'function' to be a map")
 	}
diff --git a/pkg/tools/web.go b/pkg/tools/web.go
index 301e00daf..059437889 100644
--- a/pkg/tools/web.go
+++ b/pkg/tools/web.go
@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -84,6 +85,88 @@ func (p *BraveSearchProvider) Search(ctx context.Context, query string, count in
 	return strings.Join(lines, "\n"), nil
 }
 
+type TavilySearchProvider struct {
+	apiKey  string
+	baseURL string
+}
+
+func (p *TavilySearchProvider) Search(ctx context.Context, query string, count int) (string, error) {
+	searchURL := p.baseURL
+	if searchURL == "" {
+		searchURL = "https://api.tavily.com/search"
+	}
+
+	payload := map[string]any{
+		"api_key":             p.apiKey,
+		"query":               query,
+		"search_depth":        "advanced",
+		"include_answer":      false,
+		"include_images":      false,
+		"include_raw_content": "false",
+		"max_results":         count,
+	}
+
+	bodyBytes, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal payload: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", searchURL, bytes.NewBuffer(bodyBytes))
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", userAgent)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("tavily api error (status %d): %s", resp.StatusCode, string(body))
+	}
+
+	var searchResp struct {
+		Results []struct {
+			Title   string `json:"title"`
+			URL     string `json:"url"`
+			Content string `json:"content"`
+		} `json:"results"`
+	}
+
+	if err := json.Unmarshal(body, &searchResp); err != nil {
+		return "", fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	results := searchResp.Results
+	if len(results) == 0 {
+		return fmt.Sprintf("No results for: %s", query), nil
+	}
+
+	var lines []string
+	lines = append(lines, fmt.Sprintf("Results for: %s (via Tavily)", query))
+	for i, item := range results {
+		if i >= count {
+			break
+		}
+		lines = append(lines, fmt.Sprintf("%d. %s\n   %s", i+1, item.Title, item.URL))
+		if item.Content != "" {
+			lines = append(lines, fmt.Sprintf("   %s", item.Content))
+		}
+	}
+
+	return strings.Join(lines, "\n"), nil
+}
+
 type DuckDuckGoSearchProvider struct{}
 
 func (p *DuckDuckGoSearchProvider) Search(ctx context.Context, query string, count int) (string, error) {
@@ -256,6 +339,10 @@ type WebSearchToolOptions struct {
 	BraveAPIKey          string
 	BraveMaxResults      int
 	BraveEnabled         bool
+	TavilyAPIKey         string
+	TavilyBaseURL        string
+	TavilyMaxResults     int
+	TavilyEnabled        bool
 	DuckDuckGoMaxResults int
 	DuckDuckGoEnabled    bool
 	PerplexityAPIKey     string
@@ -267,7 +354,7 @@ func NewWebSearchTool(opts WebSearchToolOptions) *WebSearchTool {
 	var provider SearchProvider
 	maxResults := 5
 
-	// Priority: Perplexity > Brave > DuckDuckGo
+	// Priority: Perplexity > Brave > Tavily > DuckDuckGo
 	if opts.PerplexityEnabled && opts.PerplexityAPIKey != "" {
 		provider = &PerplexitySearchProvider{apiKey: opts.PerplexityAPIKey}
 		if opts.PerplexityMaxResults > 0 {
@@ -278,6 +365,14 @@ func NewWebSearchTool(opts WebSearchToolOptions) *WebSearchTool {
 		if opts.BraveMaxResults > 0 {
 			maxResults = opts.BraveMaxResults
 		}
+	} else if opts.TavilyEnabled && opts.TavilyAPIKey != "" {
+		provider = &TavilySearchProvider{
+			apiKey:  opts.TavilyAPIKey,
+			baseURL: opts.TavilyBaseURL,
+		}
+		if opts.TavilyMaxResults > 0 {
+			maxResults = opts.TavilyMaxResults
+		}
 	} else if opts.DuckDuckGoEnabled {
 		provider = &DuckDuckGoSearchProvider{}
 		if opts.DuckDuckGoMaxResults > 0 {
diff --git a/pkg/tools/web_test.go b/pkg/tools/web_test.go
index d999d8958..75e0d8d16 100644
--- a/pkg/tools/web_test.go
+++ b/pkg/tools/web_test.go
@@ -333,3 +333,75 @@ func TestWebTool_WebFetch_MissingDomain(t *testing.T) {
 		t.Errorf("Expected domain error message, got ForLLM: %s", result.ForLLM)
 	}
 }
+
+// TestWebTool_TavilySearch_Success verifies successful Tavily search
+func TestWebTool_TavilySearch_Success(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "POST" {
+			t.Errorf("Expected POST request, got %s", r.Method)
+		}
+		if r.Header.Get("Content-Type") != "application/json" {
+			t.Errorf("Expected Content-Type application/json, got %s", r.Header.Get("Content-Type"))
+		}
+
+		// Verify payload
+		var payload map[string]any
+		json.NewDecoder(r.Body).Decode(&payload)
+		if payload["api_key"] != "test-key" {
+			t.Errorf("Expected api_key test-key, got %v", payload["api_key"])
+		}
+		if payload["query"] != "test query" {
+			t.Errorf("Expected query 'test query', got %v", payload["query"])
+		}
+
+		// Return mock response
+		response := map[string]any{
+			"results": []map[string]any{
+				{
+					"title":   "Test Result 1",
+					"url":     "https://example.com/1",
+					"content": "Content for result 1",
+				},
+				{
+					"title":   "Test Result 2",
+					"url":     "https://example.com/2",
+					"content": "Content for result 2",
+				},
+			},
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	tool := NewWebSearchTool(WebSearchToolOptions{
+		TavilyEnabled:    true,
+		TavilyAPIKey:     "test-key",
+		TavilyBaseURL:    server.URL,
+		TavilyMaxResults: 5,
+	})
+
+	ctx := context.Background()
+	args := map[string]any{
+		"query": "test query",
+	}
+
+	result := tool.Execute(ctx, args)
+
+	// Success should not be an error
+	if result.IsError {
+		t.Errorf("Expected success, got IsError=true: %s", result.ForLLM)
+	}
+
+	// ForUser should contain result titles and URLs
+	if !strings.Contains(result.ForUser, "Test Result 1") ||
+		!strings.Contains(result.ForUser, "https://example.com/1") {
+		t.Errorf("Expected results in output, got: %s", result.ForUser)
+	}
+
+	// Should mention via Tavily
+	if !strings.Contains(result.ForUser, "via Tavily") {
+		t.Errorf("Expected 'via Tavily' in output, got: %s", result.ForUser)
+	}
+}

From 4a73415e0516e0f954267c2ee797896d2ec770bb Mon Sep 17 00:00:00 2001
From: Kai Xia <kaix+github@fastmail.com>
Date: Mon, 23 Feb 2026 08:09:26 +1100
Subject: [PATCH 17/52] golangci-lint run --fix on master

Signed-off-by: Kai Xia <kaix+github@fastmail.com>
---
 pkg/tools/registry_test.go | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/pkg/tools/registry_test.go b/pkg/tools/registry_test.go
index 33978e543..8ae13b20c 100644
--- a/pkg/tools/registry_test.go
+++ b/pkg/tools/registry_test.go
@@ -14,14 +14,14 @@ import (
 type mockRegistryTool struct {
 	name   string
 	desc   string
-	params map[string]interface{}
+	params map[string]any
 	result *ToolResult
 }
 
-func (m *mockRegistryTool) Name() string                       { return m.name }
-func (m *mockRegistryTool) Description() string                { return m.desc }
-func (m *mockRegistryTool) Parameters() map[string]interface{} { return m.params }
-func (m *mockRegistryTool) Execute(_ context.Context, _ map[string]interface{}) *ToolResult {
+func (m *mockRegistryTool) Name() string               { return m.name }
+func (m *mockRegistryTool) Description() string        { return m.desc }
+func (m *mockRegistryTool) Parameters() map[string]any { return m.params }
+func (m *mockRegistryTool) Execute(_ context.Context, _ map[string]any) *ToolResult {
 	return m.result
 }
 
@@ -51,7 +51,7 @@ func newMockTool(name, desc string) *mockRegistryTool {
 	return &mockRegistryTool{
 		name:   name,
 		desc:   desc,
-		params: map[string]interface{}{"type": "object"},
+		params: map[string]any{"type": "object"},
 		result: SilentResult("ok"),
 	}
 }
@@ -109,7 +109,7 @@ func TestToolRegistry_Execute_Success(t *testing.T) {
 	r.Register(&mockRegistryTool{
 		name:   "greet",
 		desc:   "says hello",
-		params: map[string]interface{}{},
+		params: map[string]any{},
 		result: SilentResult("hello"),
 	})
 
@@ -203,7 +203,7 @@ func TestToolRegistry_GetDefinitions(t *testing.T) {
 	if defs[0]["type"] != "function" {
 		t.Errorf("expected type 'function', got %v", defs[0]["type"])
 	}
-	fn, ok := defs[0]["function"].(map[string]interface{})
+	fn, ok := defs[0]["function"].(map[string]any)
 	if !ok {
 		t.Fatal("expected 'function' key to be a map")
 	}
@@ -217,7 +217,7 @@ func TestToolRegistry_GetDefinitions(t *testing.T) {
 
 func TestToolRegistry_ToProviderDefs(t *testing.T) {
 	r := NewToolRegistry()
-	params := map[string]interface{}{"type": "object", "properties": map[string]interface{}{}}
+	params := map[string]any{"type": "object", "properties": map[string]any{}}
 	r.Register(&mockRegistryTool{
 		name:   "beta",
 		desc:   "tool B",
@@ -310,7 +310,7 @@ func TestToolToSchema(t *testing.T) {
 	if schema["type"] != "function" {
 		t.Errorf("expected type 'function', got %v", schema["type"])
 	}
-	fn, ok := schema["function"].(map[string]interface{})
+	fn, ok := schema["function"].(map[string]any)
 	if !ok {
 		t.Fatal("expected 'function' to be a map")
 	}

From 8928f83c7ff254ec1c74bff1d03aca20220cb702 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kai=20Xia=28=E5=A4=8F=E6=81=BA=29?=
 <xiaket@users.noreply.github.com>
Date: Mon, 23 Feb 2026 09:45:17 +1100
Subject: [PATCH 18/52] remove old roadmap (#632)

---
 README.fr.md                              |   2 +-
 README.md                                 |   2 +-
 README.pt-br.md                           |   2 +-
 README.vi.md                              |   2 +-
 README.zh.md                              |   2 +-
 docs/picoclaw_community_roadmap_260216.md | 112 ----------------------
 6 files changed, 5 insertions(+), 117 deletions(-)
 delete mode 100644 docs/picoclaw_community_roadmap_260216.md

diff --git a/README.fr.md b/README.fr.md
index 7199f7098..a762870ff 100644
--- a/README.fr.md
+++ b/README.fr.md
@@ -50,7 +50,7 @@
 
 ## 📢 Actualités
 
-2026-02-16 🎉 PicoClaw a atteint 12K étoiles en une semaine ! Merci à tous pour votre soutien ! PicoClaw grandit plus vite que nous ne l'avions jamais imaginé. Vu le volume élevé de PR, nous avons un besoin urgent de mainteneurs communautaires. Nos rôles de bénévoles et notre feuille de route sont officiellement publiés [ici](docs/picoclaw_community_roadmap_260216.md) — nous avons hâte de vous accueillir !
+2026-02-16 🎉 PicoClaw a atteint 12K étoiles en une semaine ! Merci à tous pour votre soutien ! PicoClaw grandit plus vite que nous ne l'avions jamais imaginé. Vu le volume élevé de PR, nous avons un besoin urgent de mainteneurs communautaires. Nos rôles de bénévoles et notre feuille de route sont officiellement publiés [ici](docs/ROADMAP.md) — nous avons hâte de vous accueillir !
 
 2026-02-13 🎉 PicoClaw a atteint 5000 étoiles en 4 jours ! Merci à la communauté ! Nous finalisons la **Feuille de Route du Projet** et mettons en place le **Groupe de Développeurs** pour accélérer le développement de PicoClaw.
 🚀 **Appel à l'action :** Soumettez vos demandes de fonctionnalités dans les GitHub Discussions. Nous les examinerons et les prioriserons lors de notre prochaine réunion hebdomadaire.
diff --git a/README.md b/README.md
index 825f57340..955255f2e 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@
 
 ## 📢 News
 
-2026-02-16 🎉 PicoClaw hit 12K stars in one week! Thank you all for your support! PicoClaw is growing faster than we ever imagined. Given the high volume of PRs, we urgently need community maintainers. Our volunteer roles and roadmap are officially posted [here](docs/picoclaw_community_roadmap_260216.md) —we can’t wait to have you on board!
+2026-02-16 🎉 PicoClaw hit 12K stars in one week! Thank you all for your support! PicoClaw is growing faster than we ever imagined. Given the high volume of PRs, we urgently need community maintainers. Our volunteer roles and roadmap are officially posted [here](docs/ROADMAP.md) —we can’t wait to have you on board!
 
 2026-02-13 🎉 PicoClaw hit 5000 stars in 4days! Thank you for the community! There are so many PRs & issues coming in (during Chinese New Year holidays), we are finalizing the Project Roadmap and setting up the Developer Group to accelerate PicoClaw's development.  
 🚀 Call to Action: Please submit your feature requests in GitHub Discussions. We will review and prioritize them during our upcoming weekly meeting.
diff --git a/README.pt-br.md b/README.pt-br.md
index ec8fe8e1c..900ee7932 100644
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -50,7 +50,7 @@
 
 ## 📢 Novidades
 
-2026-02-16 🎉 PicoClaw atingiu 12K stars em uma semana! Obrigado a todos pelo apoio! O PicoClaw está crescendo mais rápido do que jamais imaginamos. Dado o alto volume de PRs, precisamos urgentemente de maintainers da comunidade. Nossos papéis de voluntários e roadmap foram publicados oficialmente [aqui](docs/picoclaw_community_roadmap_260216.md) — estamos ansiosos para ter você a bordo!
+2026-02-16 🎉 PicoClaw atingiu 12K stars em uma semana! Obrigado a todos pelo apoio! O PicoClaw está crescendo mais rápido do que jamais imaginamos. Dado o alto volume de PRs, precisamos urgentemente de maintainers da comunidade. Nossos papéis de voluntários e roadmap foram publicados oficialmente [aqui](docs/ROADMAP.md) — estamos ansiosos para ter você a bordo!
 
 2026-02-13 🎉 PicoClaw atingiu 5000 stars em 4 dias! Obrigado à comunidade! Estamos finalizando o **Roadmap do Projeto** e configurando o **Grupo de Desenvolvedores** para acelerar o desenvolvimento do PicoClaw.
 
diff --git a/README.vi.md b/README.vi.md
index 161842933..29ff12bb0 100644
--- a/README.vi.md
+++ b/README.vi.md
@@ -50,7 +50,7 @@
 
 ## 📢 Tin tức
 
-2026-02-16 🎉 PicoClaw đạt 12K stars chỉ trong một tuần! Cảm ơn tất cả mọi người! PicoClaw đang phát triển nhanh hơn chúng tôi tưởng tượng. Do số lượng PR tăng cao, chúng tôi cấp thiết cần maintainer từ cộng đồng. Các vai trò tình nguyện viên và roadmap đã được công bố [tại đây](docs/picoclaw_community_roadmap_260216.md) — rất mong đón nhận sự tham gia của bạn!
+2026-02-16 🎉 PicoClaw đạt 12K stars chỉ trong một tuần! Cảm ơn tất cả mọi người! PicoClaw đang phát triển nhanh hơn chúng tôi tưởng tượng. Do số lượng PR tăng cao, chúng tôi cấp thiết cần maintainer từ cộng đồng. Các vai trò tình nguyện viên và roadmap đã được công bố [tại đây](docs/ROADMAP.md) — rất mong đón nhận sự tham gia của bạn!
 
 2026-02-13 🎉 PicoClaw đạt 5000 stars trong 4 ngày! Cảm ơn cộng đồng! Chúng tôi đang hoàn thiện **Lộ trình dự án (Roadmap)** và thiết lập **Nhóm phát triển** để đẩy nhanh tốc độ phát triển PicoClaw.  
 🚀 **Kêu gọi hành động:** Vui lòng gửi yêu cầu tính năng tại GitHub Discussions. Chúng tôi sẽ xem xét và ưu tiên trong cuộc họp hàng tuần.
diff --git a/README.zh.md b/README.zh.md
index fd188567d..17a736fec 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -52,7 +52,7 @@
 
 ## 📢 新闻 (News)
 
-2026-02-16 🎉 PicoClaw 在一周内突破了12K star! 感谢大家的关注！PicoClaw 的成长速度超乎我们预期. 由于PR数量的快速膨胀，我们亟需社区开发者参与维护. 我们需要的志愿者角色和roadmap已经发布到了[这里](docs/picoclaw_community_roadmap_260216.md), 期待你的参与！
+2026-02-16 🎉 PicoClaw 在一周内突破了12K star! 感谢大家的关注！PicoClaw 的成长速度超乎我们预期. 由于PR数量的快速膨胀，我们亟需社区开发者参与维护. 我们需要的志愿者角色和roadmap已经发布到了[这里](docs/ROADMAP.md), 期待你的参与！
 
 2026-02-13 🎉 **PicoClaw 在 4 天内突破 5000 Stars！** 感谢社区的支持！由于正值中国春节假期，PR 和 Issue 涌入较多，我们正在利用这段时间敲定 **项目路线图 (Roadmap)** 并组建 **开发者群组**，以便加速 PicoClaw 的开发。
 🚀 **行动号召：** 请在 GitHub Discussions 中提交您的功能请求 (Feature Requests)。我们将在接下来的周会上进行审查和优先级排序。
diff --git a/docs/picoclaw_community_roadmap_260216.md b/docs/picoclaw_community_roadmap_260216.md
deleted file mode 100644
index 95de768c6..000000000
--- a/docs/picoclaw_community_roadmap_260216.md
+++ /dev/null
@@ -1,112 +0,0 @@
-## 🚀 Join the PicoClaw Journey: Call for Community Volunteers & Roadmap Reveal
-
-**Hello, PicoClaw Community!**
-
-First, a massive thank you to everyone for your enthusiasm and PR contributions. It is because of you that PicoClaw continues to iterate and evolve so rapidly. Thanks to the simplicity and accessibility of the **Go language**, we’ve seen a non-stop stream of high-quality PRs!
-
-PicoClaw is growing much faster than we anticipated. As we are currently in the midst of the **Chinese New Year holiday**, we are looking to recruit community volunteers to help us maintain this incredible momentum.
-
-This document outlines the specific volunteer roles we need right now and provides a look at our upcoming **Roadmap**.
-
-### 🎁 Community Perks
-
-To show our appreciation, developers who officially join our community operations will receive:
-
-* **Exclusive AI Hardware:** Our upcoming, unreleased AI device.
-* **Token Discounts:** Potential discounts on LLM tokens (currently in negotiations with major providers).
-
-### 🎥 Calling All Content Creators!
-
-Not a developer? You can still help! We welcome users to post **PicoClaw reviews or tutorials**.
-
-* **Twitter:** Use the tag **#picoclaw** and mention **@SipeedIO**.
-* **Bilibili:** Mention **@Sipeed矽速科技** or send us a DM.
-We will be rewarding high-quality content creators with the same perks as our community developers!
-
----
-
-## 🛠️ Urgent Volunteer Roles
-
-We are looking for experts in the following areas:
-
-1. **Issue/PR Reviewers**
-* **The Mission:** With PRs and Issues exploding in volume, we need help with initial triage, evaluation, and merging.
-* **Focus:** Preliminary merging and community health. Efficiency optimization and security audits will be handled by specialized roles.
-
-
-2. **Resource Optimization Experts**
-* **The Mission:** Rapid growth has introduced dependencies that are making PicoClaw a bit "heavy." We want to keep it lean.
-* **Focus:** Analyzing resource growth between releases and trimming redundancy.
-* **Priority:** **RAM usage optimization** > Binary size reduction.
-
-
-3. **Security Audit & Bug Fixes**
-* **The Mission:** Due to the "vibe coding" nature of our early stages, we need a thorough review of network security and AI permission management.
-* **Focus:** Auditing the codebase for vulnerabilities and implementing robust fixes.
-
-
-4. **Documentation & DX (Developer Experience)**
-* **The Mission:** Our current README is a bit outdated. We need "step-by-step" guides that even beginners can follow.
-* **Focus:** Creating clear, user-friendly documentation for both setup and development.
-
-
-5. **AI-Powered CI/CD Optimization**
-* **The Mission:** PicoClaw started as a "vibe coding" experiment; now we want to use AI to manage it.
-* **Focus:** Automating builds with AI and exploring AI-driven issue resolution.
-
-**How to Apply:** > If you are interested in any of the roles above, please send an email to support@sipeed.com with the subject line: [Apply: PicoClaw Expert Volunteer] + Your Desired Role.   
-Please include a brief introduction and any relevant experience or portfolio links. We will review all applications and grant project permissions to selected contributors!
-
----
-
-## 📍 The Roadmap
-
-Interested in a specific feature? You can "claim" these tasks and start building:
-
-### 
-* **Provider:** 
-  * **Provider Refactor:** Currently being handled by **@Daming** (ETA: 5 days)
-  * You can still submit code; Daming will merge it into the new implementation.
-* **Channels:** 
-  * Support for OneBot, additional platforms
-  * attachments (images, audio, video, files).
-* **Skills:** 
-  * Implementing `find_skill` to discover tools via [ClawhHub](https://clawhub.ai) and other platforms.
-* **Operations:** * MCP Support.
-  * Android operations (e.g., botdrop).
-  * Browser automation via CDP or ActionBook.
-
-
-* **Multi-Agent Ecosystem:**
-  * **Basic Model-Agent**
-  * **Model Routing:** Small models for easy tasks, large models for hard ones (to save tokens).
-  * **Swarm Mode.**
-  * **AIEOS Integration.**
-
-
-* **Branding:** 
-  * **Logo**: We need a cute logo! We’re leaning toward a **Mantis Shrimp**—small, but packs a legendary punch!
-
-
-We have officially created these tasks as GitHub Issues, all marked with the roadmap tag.   
-This list will be updated continuously as we progress.   
-If you would like to claim a task, please feel free to start a conversation by commenting directly on the corresponding issue!
-
----
-
-## 🤝 How to Join
-
-**Everything is open to your creativity!** If you have a wild idea, just PR it.
-
-1. **The Fast Track:** Once you have at least **one merged PR**, you are eligible to join our **Developer Discord** to help plan the future of PicoClaw.
-2. **The Application Track:** If you haven’t submitted a PR yet but want to dive in, email **support@sipeed.com** with the subject:
-> `[Apply Join PicoClaw Dev Group] + Your GitHub Account`
-> Include the role you're interested in and any evidence of your development experience.
-
-
-
-### Looking Ahead
-
-Powered by PicoClaw, we are crafting a Swarm AI Assistant to transform your environment into a seamless network of personal stewards. By automating the friction of daily life, we empower you to transcend the ordinary and freely explore your creative potential.
-
-**Finally, Happy Chinese New Year to everyone!** May PicoClaw gallop forward in this **Year of the Horse!** 🐎

From 4cc8b90da94d9695d3edad52281cefdc58db8e58 Mon Sep 17 00:00:00 2001
From: Vidish <57653368+ulolol@users.noreply.github.com>
Date: Mon, 23 Feb 2026 09:42:34 +0530
Subject: [PATCH 19/52] Fix: missing Tavily config in loop.go, and the invalid
 config param in web_search (#660)

---
 pkg/agent/loop.go | 4 ++++
 pkg/tools/web.go  | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index b36f4a0c4..bf229ad74 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -97,6 +97,10 @@ func registerSharedTools(
 			BraveAPIKey:          cfg.Tools.Web.Brave.APIKey,
 			BraveMaxResults:      cfg.Tools.Web.Brave.MaxResults,
 			BraveEnabled:         cfg.Tools.Web.Brave.Enabled,
+			TavilyAPIKey:         cfg.Tools.Web.Tavily.APIKey,
+			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,
 			PerplexityAPIKey:     cfg.Tools.Web.Perplexity.APIKey,
diff --git a/pkg/tools/web.go b/pkg/tools/web.go
index 059437889..452e95e0f 100644
--- a/pkg/tools/web.go
+++ b/pkg/tools/web.go
@@ -102,7 +102,7 @@ func (p *TavilySearchProvider) Search(ctx context.Context, query string, count i
 		"search_depth":        "advanced",
 		"include_answer":      false,
 		"include_images":      false,
-		"include_raw_content": "false",
+		"include_raw_content": false,
 		"max_results":         count,
 	}
 

From 19c698356c2aef8f618a110acef671def19f5261 Mon Sep 17 00:00:00 2001
From: 0x5487 <jawc@hotmail.com>
Date: Mon, 23 Feb 2026 17:09:53 +0800
Subject: [PATCH 20/52] fix(security): workspace sandbox avoid
 time-of-check/time-of-use (TOCTOU) races (#464)

* chore: Update default host bindings from 0.0.0.0 to 127.0.0.1 for various services and examples.

* config: Update default host bindings to 0.0.0.0 for improved Docker accessibility and add related documentation.

* refactor: reimplement filesystem tools with `os.OpenRoot` for enhanced security and simplified path validation.

* chore: revert other PR content from this branch

* docs: Update Chinese README.

* docs: Update Chinese README.

* docs: Update Chinese README.

* refactor: Reorder filesystem helper functions, extract directory entry formatting logic, and enhance `WriteFileTool`'s result message.

* feat: Enhance `mkdirAllInRoot` to prevent creating directories over existing files and add tests for directory creation functionality.

* Refactor filesystem tools to use a `fileReadWriter` interface for both host and sandboxed I/O, improving atomic writes and error handling.

* refactor: unify filesystem read/write operations with atomic write guarantees and clearer naming.

* refactor: rename `appendFileWithRW` function to `appendFile`

* refactor: unify filesystem access by introducing a `fileSystem` interface and updating tools to use it directly, removing `os.Root` dependency from `sandboxFs`.

* chore: run make fmt

* fix: `validatePath` now returns an error when the workspace is empty.
---
 pkg/tools/edit.go            | 118 ++++++++++--------
 pkg/tools/edit_test.go       | 160 +++++++++++++++++++++++-
 pkg/tools/filesystem.go      | 234 +++++++++++++++++++++++++++++------
 pkg/tools/filesystem_test.go | 227 +++++++++++++++++++++++++++++++--
 4 files changed, 630 insertions(+), 109 deletions(-)

diff --git a/pkg/tools/edit.go b/pkg/tools/edit.go
index c28ca6ca2..d3ab267bf 100644
--- a/pkg/tools/edit.go
+++ b/pkg/tools/edit.go
@@ -2,24 +2,27 @@ package tools
 
 import (
 	"context"
+	"errors"
 	"fmt"
-	"os"
+	"io/fs"
 	"strings"
 )
 
 // EditFileTool edits a file by replacing old_text with new_text.
 // The old_text must exist exactly in the file.
 type EditFileTool struct {
-	allowedDir string
-	restrict   bool
+	fs fileSystem
 }
 
 // NewEditFileTool creates a new EditFileTool with optional directory restriction.
-func NewEditFileTool(allowedDir string, restrict bool) *EditFileTool {
-	return &EditFileTool{
-		allowedDir: allowedDir,
-		restrict:   restrict,
+func NewEditFileTool(workspace string, restrict bool) *EditFileTool {
+	var fs fileSystem
+	if restrict {
+		fs = &sandboxFs{workspace: workspace}
+	} else {
+		fs = &hostFs{}
 	}
+	return &EditFileTool{fs: fs}
 }
 
 func (t *EditFileTool) Name() string {
@@ -67,49 +70,24 @@ func (t *EditFileTool) Execute(ctx context.Context, args map[string]any) *ToolRe
 		return ErrorResult("new_text is required")
 	}
 
-	resolvedPath, err := validatePath(path, t.allowedDir, t.restrict)
-	if err != nil {
+	if err := editFile(t.fs, path, oldText, newText); err != nil {
 		return ErrorResult(err.Error())
 	}
-
-	if _, err = os.Stat(resolvedPath); os.IsNotExist(err) {
-		return ErrorResult(fmt.Sprintf("file not found: %s", path))
-	}
-
-	content, err := os.ReadFile(resolvedPath)
-	if err != nil {
-		return ErrorResult(fmt.Sprintf("failed to read file: %v", err))
-	}
-
-	contentStr := string(content)
-
-	if !strings.Contains(contentStr, oldText) {
-		return ErrorResult("old_text not found in file. Make sure it matches exactly")
-	}
-
-	count := strings.Count(contentStr, oldText)
-	if count > 1 {
-		return ErrorResult(
-			fmt.Sprintf("old_text appears %d times. Please provide more context to make it unique", count),
-		)
-	}
-
-	newContent := strings.Replace(contentStr, oldText, newText, 1)
-
-	if err := os.WriteFile(resolvedPath, []byte(newContent), 0o644); err != nil {
-		return ErrorResult(fmt.Sprintf("failed to write file: %v", err))
-	}
-
 	return SilentResult(fmt.Sprintf("File edited: %s", path))
 }
 
 type AppendFileTool struct {
-	workspace string
-	restrict  bool
+	fs fileSystem
 }
 
 func NewAppendFileTool(workspace string, restrict bool) *AppendFileTool {
-	return &AppendFileTool{workspace: workspace, restrict: restrict}
+	var fs fileSystem
+	if restrict {
+		fs = &sandboxFs{workspace: workspace}
+	} else {
+		fs = &hostFs{}
+	}
+	return &AppendFileTool{fs: fs}
 }
 
 func (t *AppendFileTool) Name() string {
@@ -148,20 +126,52 @@ func (t *AppendFileTool) Execute(ctx context.Context, args map[string]any) *Tool
 		return ErrorResult("content is required")
 	}
 
-	resolvedPath, err := validatePath(path, t.workspace, t.restrict)
-	if err != nil {
+	if err := appendFile(t.fs, path, content); err != nil {
 		return ErrorResult(err.Error())
 	}
-
-	f, err := os.OpenFile(resolvedPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
-	if err != nil {
-		return ErrorResult(fmt.Sprintf("failed to open file: %v", err))
-	}
-	defer f.Close()
-
-	if _, err := f.WriteString(content); err != nil {
-		return ErrorResult(fmt.Sprintf("failed to append to file: %v", err))
-	}
-
 	return SilentResult(fmt.Sprintf("Appended to %s", path))
 }
+
+// editFile reads the file via sysFs, performs the replacement, and writes back.
+// It uses a fileSystem interface, allowing the same logic for both restricted and unrestricted modes.
+func editFile(sysFs fileSystem, path, oldText, newText string) error {
+	content, err := sysFs.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	newContent, err := replaceEditContent(content, oldText, newText)
+	if err != nil {
+		return err
+	}
+
+	return sysFs.WriteFile(path, newContent)
+}
+
+// appendFile reads the existing content (if any) via sysFs, appends new content, and writes back.
+func appendFile(sysFs fileSystem, path, appendContent string) error {
+	content, err := sysFs.ReadFile(path)
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return err
+	}
+
+	newContent := append(content, []byte(appendContent)...)
+	return sysFs.WriteFile(path, newContent)
+}
+
+// replaceEditContent handles the core logic of finding and replacing a single occurrence of oldText.
+func replaceEditContent(content []byte, oldText, newText string) ([]byte, error) {
+	contentStr := string(content)
+
+	if !strings.Contains(contentStr, oldText) {
+		return nil, fmt.Errorf("old_text not found in file. Make sure it matches exactly")
+	}
+
+	count := strings.Count(contentStr, oldText)
+	if count > 1 {
+		return nil, fmt.Errorf("old_text appears %d times. Please provide more context to make it unique", count)
+	}
+
+	newContent := strings.Replace(contentStr, oldText, newText, 1)
+	return []byte(newContent), nil
+}
diff --git a/pkg/tools/edit_test.go b/pkg/tools/edit_test.go
index 6780dd9f6..83a7e778c 100644
--- a/pkg/tools/edit_test.go
+++ b/pkg/tools/edit_test.go
@@ -6,6 +6,8 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 // TestEditTool_EditFile_Success verifies successful file editing
@@ -151,14 +153,18 @@ func TestEditTool_EditFile_OutsideAllowedDir(t *testing.T) {
 	result := tool.Execute(ctx, args)
 
 	// Should return error result
-	if !result.IsError {
-		t.Errorf("Expected error when path is outside allowed directory")
-	}
+	assert.True(t, result.IsError, "Expected error when path is outside allowed directory")
 
 	// Should mention outside allowed directory
-	if !strings.Contains(result.ForLLM, "outside") && !strings.Contains(result.ForUser, "outside") {
-		t.Errorf("Expected 'outside allowed' message, got ForLLM: %s", result.ForLLM)
-	}
+	// Note: ErrorResult only sets ForLLM by default, so ForUser might be empty.
+	// We check ForLLM as it's the primary error channel.
+	assert.True(
+		t,
+		strings.Contains(result.ForLLM, "outside") || strings.Contains(result.ForLLM, "access denied") ||
+			strings.Contains(result.ForLLM, "escapes"),
+		"Expected 'outside allowed' or 'access denied' message, got ForLLM: %s",
+		result.ForLLM,
+	)
 }
 
 // TestEditTool_EditFile_MissingPath verifies error handling for missing path
@@ -287,3 +293,145 @@ func TestEditTool_AppendFile_MissingContent(t *testing.T) {
 		t.Errorf("Expected error when content is missing")
 	}
 }
+
+// TestReplaceEditContent verifies the helper function replaceEditContent
+func TestReplaceEditContent(t *testing.T) {
+	tests := []struct {
+		name        string
+		content     []byte
+		oldText     string
+		newText     string
+		expected    []byte
+		expectError bool
+	}{
+		{
+			name:        "successful replacement",
+			content:     []byte("hello world"),
+			oldText:     "world",
+			newText:     "universe",
+			expected:    []byte("hello universe"),
+			expectError: false,
+		},
+		{
+			name:        "old text not found",
+			content:     []byte("hello world"),
+			oldText:     "golang",
+			newText:     "rust",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name:        "multiple matches found",
+			content:     []byte("test text test"),
+			oldText:     "test",
+			newText:     "done",
+			expected:    nil,
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := replaceEditContent(tt.content, tt.oldText, tt.newText)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+// TestAppendFileTool_AppendToNonExistent_Restricted verifies that AppendFileTool in restricted mode
+// can append to a file that does not yet exist — it should silently create the file.
+// This exercises the errors.Is(err, fs.ErrNotExist) path in appendFileWithRW + rootRW.
+func TestAppendFileTool_AppendToNonExistent_Restricted(t *testing.T) {
+	workspace := t.TempDir()
+	tool := NewAppendFileTool(workspace, true)
+	ctx := context.Background()
+
+	args := map[string]any{
+		"path":    "brand_new_file.txt",
+		"content": "first content",
+	}
+
+	result := tool.Execute(ctx, args)
+	assert.False(
+		t,
+		result.IsError,
+		"Expected success when appending to non-existent file in restricted mode, got: %s",
+		result.ForLLM,
+	)
+
+	// Verify the file was created with correct content
+	data, err := os.ReadFile(filepath.Join(workspace, "brand_new_file.txt"))
+	assert.NoError(t, err)
+	assert.Equal(t, "first content", string(data))
+}
+
+// TestAppendFileTool_Restricted_Success verifies that AppendFileTool in restricted mode
+// correctly appends to an existing file within the sandbox.
+func TestAppendFileTool_Restricted_Success(t *testing.T) {
+	workspace := t.TempDir()
+	testFile := "existing.txt"
+	err := os.WriteFile(filepath.Join(workspace, testFile), []byte("initial"), 0o644)
+	assert.NoError(t, err)
+
+	tool := NewAppendFileTool(workspace, true)
+	ctx := context.Background()
+	args := map[string]any{
+		"path":    testFile,
+		"content": " appended",
+	}
+
+	result := tool.Execute(ctx, args)
+	assert.False(t, result.IsError, "Expected success, got: %s", result.ForLLM)
+	assert.True(t, result.Silent)
+
+	data, err := os.ReadFile(filepath.Join(workspace, testFile))
+	assert.NoError(t, err)
+	assert.Equal(t, "initial appended", string(data))
+}
+
+// TestEditFileTool_Restricted_InPlaceEdit verifies that EditFileTool in restricted mode
+// correctly edits a file using the single-open editFileInRoot path.
+func TestEditFileTool_Restricted_InPlaceEdit(t *testing.T) {
+	workspace := t.TempDir()
+	testFile := "edit_target.txt"
+	err := os.WriteFile(filepath.Join(workspace, testFile), []byte("Hello World"), 0o644)
+	assert.NoError(t, err)
+
+	tool := NewEditFileTool(workspace, true)
+	ctx := context.Background()
+	args := map[string]any{
+		"path":     testFile,
+		"old_text": "World",
+		"new_text": "Go",
+	}
+
+	result := tool.Execute(ctx, args)
+	assert.False(t, result.IsError, "Expected success, got: %s", result.ForLLM)
+	assert.True(t, result.Silent)
+
+	data, err := os.ReadFile(filepath.Join(workspace, testFile))
+	assert.NoError(t, err)
+	assert.Equal(t, "Hello Go", string(data))
+}
+
+// TestEditFileTool_Restricted_FileNotFound verifies that editFileInRoot returns a proper
+// error message when the target file does not exist.
+func TestEditFileTool_Restricted_FileNotFound(t *testing.T) {
+	workspace := t.TempDir()
+	tool := NewEditFileTool(workspace, true)
+	ctx := context.Background()
+	args := map[string]any{
+		"path":     "no_such_file.txt",
+		"old_text": "old",
+		"new_text": "new",
+	}
+
+	result := tool.Execute(ctx, args)
+	assert.True(t, result.IsError)
+	assert.Contains(t, result.ForLLM, "not found")
+}
diff --git a/pkg/tools/filesystem.go b/pkg/tools/filesystem.go
index 1bf50906e..37db8b4ae 100644
--- a/pkg/tools/filesystem.go
+++ b/pkg/tools/filesystem.go
@@ -3,15 +3,17 @@ package tools
 import (
 	"context"
 	"fmt"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 )
 
 // validatePath ensures the given path is within the workspace if restrict is true.
 func validatePath(path, workspace string, restrict bool) (string, error) {
 	if workspace == "" {
-		return path, nil
+		return path, fmt.Errorf("workspace is not defined")
 	}
 
 	absWorkspace, err := filepath.Abs(workspace)
@@ -76,16 +78,21 @@ func resolveExistingAncestor(path string) (string, error) {
 
 func isWithinWorkspace(candidate, workspace string) bool {
 	rel, err := filepath.Rel(filepath.Clean(workspace), filepath.Clean(candidate))
-	return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(os.PathSeparator))
+	return err == nil && filepath.IsLocal(rel)
 }
 
 type ReadFileTool struct {
-	workspace string
-	restrict  bool
+	fs fileSystem
 }
 
 func NewReadFileTool(workspace string, restrict bool) *ReadFileTool {
-	return &ReadFileTool{workspace: workspace, restrict: restrict}
+	var fs fileSystem
+	if restrict {
+		fs = &sandboxFs{workspace: workspace}
+	} else {
+		fs = &hostFs{}
+	}
+	return &ReadFileTool{fs: fs}
 }
 
 func (t *ReadFileTool) Name() string {
@@ -115,26 +122,25 @@ func (t *ReadFileTool) Execute(ctx context.Context, args map[string]any) *ToolRe
 		return ErrorResult("path is required")
 	}
 
-	resolvedPath, err := validatePath(path, t.workspace, t.restrict)
+	content, err := t.fs.ReadFile(path)
 	if err != nil {
 		return ErrorResult(err.Error())
 	}
-
-	content, err := os.ReadFile(resolvedPath)
-	if err != nil {
-		return ErrorResult(fmt.Sprintf("failed to read file: %v", err))
-	}
-
 	return NewToolResult(string(content))
 }
 
 type WriteFileTool struct {
-	workspace string
-	restrict  bool
+	fs fileSystem
 }
 
 func NewWriteFileTool(workspace string, restrict bool) *WriteFileTool {
-	return &WriteFileTool{workspace: workspace, restrict: restrict}
+	var fs fileSystem
+	if restrict {
+		fs = &sandboxFs{workspace: workspace}
+	} else {
+		fs = &hostFs{}
+	}
+	return &WriteFileTool{fs: fs}
 }
 
 func (t *WriteFileTool) Name() string {
@@ -173,30 +179,25 @@ func (t *WriteFileTool) Execute(ctx context.Context, args map[string]any) *ToolR
 		return ErrorResult("content is required")
 	}
 
-	resolvedPath, err := validatePath(path, t.workspace, t.restrict)
-	if err != nil {
+	if err := t.fs.WriteFile(path, []byte(content)); err != nil {
 		return ErrorResult(err.Error())
 	}
 
-	dir := filepath.Dir(resolvedPath)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return ErrorResult(fmt.Sprintf("failed to create directory: %v", err))
-	}
-
-	if err := os.WriteFile(resolvedPath, []byte(content), 0o644); err != nil {
-		return ErrorResult(fmt.Sprintf("failed to write file: %v", err))
-	}
-
 	return SilentResult(fmt.Sprintf("File written: %s", path))
 }
 
 type ListDirTool struct {
-	workspace string
-	restrict  bool
+	fs fileSystem
 }
 
 func NewListDirTool(workspace string, restrict bool) *ListDirTool {
-	return &ListDirTool{workspace: workspace, restrict: restrict}
+	var fs fileSystem
+	if restrict {
+		fs = &sandboxFs{workspace: workspace}
+	} else {
+		fs = &hostFs{}
+	}
+	return &ListDirTool{fs: fs}
 }
 
 func (t *ListDirTool) Name() string {
@@ -226,24 +227,179 @@ func (t *ListDirTool) Execute(ctx context.Context, args map[string]any) *ToolRes
 		path = "."
 	}
 
-	resolvedPath, err := validatePath(path, t.workspace, t.restrict)
-	if err != nil {
-		return ErrorResult(err.Error())
-	}
-
-	entries, err := os.ReadDir(resolvedPath)
+	entries, err := t.fs.ReadDir(path)
 	if err != nil {
 		return ErrorResult(fmt.Sprintf("failed to read directory: %v", err))
 	}
+	return formatDirEntries(entries)
+}
 
-	result := ""
+func formatDirEntries(entries []os.DirEntry) *ToolResult {
+	var result strings.Builder
 	for _, entry := range entries {
 		if entry.IsDir() {
-			result += "DIR:  " + entry.Name() + "\n"
+			result.WriteString("DIR:  " + entry.Name() + "\n")
 		} else {
-			result += "FILE: " + entry.Name() + "\n"
+			result.WriteString("FILE: " + entry.Name() + "\n")
+		}
+	}
+	return NewToolResult(result.String())
+}
+
+// fileSystem abstracts reading, writing, and listing files, allowing both
+// unrestricted (host filesystem) and sandbox (os.Root) implementations to share the same polymorphic interface.
+type fileSystem interface {
+	ReadFile(path string) ([]byte, error)
+	WriteFile(path string, data []byte) error
+	ReadDir(path string) ([]os.DirEntry, error)
+}
+
+// hostFs is an unrestricted fileReadWriter that operates directly on the host filesystem.
+type hostFs struct{}
+
+func (h *hostFs) ReadFile(path string) ([]byte, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("failed to read file: file not found: %w", err)
+		}
+		if os.IsPermission(err) {
+			return nil, fmt.Errorf("failed to read file: access denied: %w", err)
+		}
+		return nil, fmt.Errorf("failed to read file: %w", err)
+	}
+	return content, nil
+}
+
+func (h *hostFs) ReadDir(path string) ([]os.DirEntry, error) {
+	return os.ReadDir(path)
+}
+
+func (h *hostFs) WriteFile(path string, data []byte) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("failed to create parent directories: %w", err)
+	}
+
+	// We use a "write-then-rename" pattern here to ensure an atomic write.
+	// This prevents the target file from being left in a truncated or partial state
+	// if the operation is interrupted, as the rename operation is atomic on Linux.
+	tmpPath := fmt.Sprintf("%s.%d.tmp", path, time.Now().UnixNano())
+	if err := os.WriteFile(tmpPath, data, 0o644); err != nil {
+		os.Remove(tmpPath) // Ensure cleanup of partial/empty temp file
+		return fmt.Errorf("failed to write temp file: %w", err)
+	}
+
+	if err := os.Rename(tmpPath, path); err != nil {
+		os.Remove(tmpPath)
+		return fmt.Errorf("failed to replace original file: %w", err)
+	}
+	return nil
+}
+
+// sandboxFs is a sandboxed fileSystem that operates within a strictly defined workspace using os.Root.
+type sandboxFs struct {
+	workspace string
+}
+
+func (r *sandboxFs) execute(path string, fn func(root *os.Root, relPath string) error) error {
+	if r.workspace == "" {
+		return fmt.Errorf("workspace is not defined")
+	}
+
+	root, err := os.OpenRoot(r.workspace)
+	if err != nil {
+		return fmt.Errorf("failed to open workspace: %w", err)
+	}
+	defer root.Close()
+
+	relPath, err := getSafeRelPath(r.workspace, path)
+	if err != nil {
+		return err
+	}
+
+	return fn(root, relPath)
+}
+
+func (r *sandboxFs) ReadFile(path string) ([]byte, error) {
+	var content []byte
+	err := r.execute(path, func(root *os.Root, relPath string) error {
+		fileContent, err := root.ReadFile(relPath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return fmt.Errorf("failed to read file: file not found: %w", err)
+			}
+			// os.Root returns "escapes from parent" for paths outside the root
+			if os.IsPermission(err) || strings.Contains(err.Error(), "escapes from parent") ||
+				strings.Contains(err.Error(), "permission denied") {
+				return fmt.Errorf("failed to read file: access denied: %w", err)
+			}
+			return fmt.Errorf("failed to read file: %w", err)
+		}
+		content = fileContent
+		return nil
+	})
+	return content, err
+}
+
+func (r *sandboxFs) WriteFile(path string, data []byte) error {
+	return r.execute(path, func(root *os.Root, relPath string) error {
+		dir := filepath.Dir(relPath)
+		if dir != "." && dir != "/" {
+			if err := root.MkdirAll(dir, 0o755); err != nil {
+				return fmt.Errorf("failed to create parent directories: %w", err)
+			}
+		}
+
+		// We use a "write-then-rename" pattern here to ensure an atomic write.
+		// This prevents the target file from being left in a truncated or partial state
+		// if the operation is interrupted, as the rename operation is atomic on Linux.
+		tmpRelPath := fmt.Sprintf("%s.%d.tmp", relPath, time.Now().UnixNano())
+
+		if err := root.WriteFile(tmpRelPath, data, 0o644); err != nil {
+			root.Remove(tmpRelPath) // Ensure cleanup of partial/empty temp file
+			return fmt.Errorf("failed to write to temp file: %w", err)
+		}
+
+		if err := root.Rename(tmpRelPath, relPath); err != nil {
+			root.Remove(tmpRelPath)
+			return fmt.Errorf("failed to rename temp file over target: %w", err)
+		}
+		return nil
+	})
+}
+
+func (r *sandboxFs) ReadDir(path string) ([]os.DirEntry, error) {
+	var entries []os.DirEntry
+	err := r.execute(path, func(root *os.Root, relPath string) error {
+		dirEntries, err := fs.ReadDir(root.FS(), relPath)
+		if err != nil {
+			return err
+		}
+		entries = dirEntries
+		return nil
+	})
+	return entries, err
+}
+
+// Helper to get a safe relative path for os.Root usage
+func getSafeRelPath(workspace, path string) (string, error) {
+	if workspace == "" {
+		return "", fmt.Errorf("workspace is not defined")
+	}
+
+	rel := filepath.Clean(path)
+	if filepath.IsAbs(rel) {
+		var err error
+		rel, err = filepath.Rel(workspace, rel)
+		if err != nil {
+			return "", fmt.Errorf("failed to calculate relative path: %w", err)
 		}
 	}
 
-	return NewToolResult(result)
+	if !filepath.IsLocal(rel) {
+		return "", fmt.Errorf("path escapes workspace: %s", path)
+	}
+
+	return rel, nil
 }
diff --git a/pkg/tools/filesystem_test.go b/pkg/tools/filesystem_test.go
index 5daa3dcea..6f896e22d 100644
--- a/pkg/tools/filesystem_test.go
+++ b/pkg/tools/filesystem_test.go
@@ -2,10 +2,13 @@ package tools
 
 import (
 	"context"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 // TestFilesystemTool_ReadFile_Success verifies successful file reading
@@ -14,7 +17,7 @@ func TestFilesystemTool_ReadFile_Success(t *testing.T) {
 	testFile := filepath.Join(tmpDir, "test.txt")
 	os.WriteFile(testFile, []byte("test content"), 0o644)
 
-	tool := &ReadFileTool{}
+	tool := NewReadFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path": testFile,
@@ -41,7 +44,7 @@ func TestFilesystemTool_ReadFile_Success(t *testing.T) {
 
 // TestFilesystemTool_ReadFile_NotFound verifies error handling for missing file
 func TestFilesystemTool_ReadFile_NotFound(t *testing.T) {
-	tool := &ReadFileTool{}
+	tool := NewReadFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path": "/nonexistent_file_12345.txt",
@@ -84,7 +87,7 @@ func TestFilesystemTool_WriteFile_Success(t *testing.T) {
 	tmpDir := t.TempDir()
 	testFile := filepath.Join(tmpDir, "newfile.txt")
 
-	tool := &WriteFileTool{}
+	tool := NewWriteFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path":    testFile,
@@ -123,7 +126,7 @@ func TestFilesystemTool_WriteFile_CreateDir(t *testing.T) {
 	tmpDir := t.TempDir()
 	testFile := filepath.Join(tmpDir, "subdir", "newfile.txt")
 
-	tool := &WriteFileTool{}
+	tool := NewWriteFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path":    testFile,
@@ -149,7 +152,7 @@ func TestFilesystemTool_WriteFile_CreateDir(t *testing.T) {
 
 // TestFilesystemTool_WriteFile_MissingPath verifies error handling for missing path
 func TestFilesystemTool_WriteFile_MissingPath(t *testing.T) {
-	tool := &WriteFileTool{}
+	tool := NewWriteFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"content": "test",
@@ -165,7 +168,7 @@ func TestFilesystemTool_WriteFile_MissingPath(t *testing.T) {
 
 // TestFilesystemTool_WriteFile_MissingContent verifies error handling for missing content
 func TestFilesystemTool_WriteFile_MissingContent(t *testing.T) {
-	tool := &WriteFileTool{}
+	tool := NewWriteFileTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path": "/tmp/test.txt",
@@ -192,7 +195,7 @@ func TestFilesystemTool_ListDir_Success(t *testing.T) {
 	os.WriteFile(filepath.Join(tmpDir, "file2.txt"), []byte("content"), 0o644)
 	os.Mkdir(filepath.Join(tmpDir, "subdir"), 0o755)
 
-	tool := &ListDirTool{}
+	tool := NewListDirTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path": tmpDir,
@@ -216,7 +219,7 @@ func TestFilesystemTool_ListDir_Success(t *testing.T) {
 
 // TestFilesystemTool_ListDir_NotFound verifies error handling for non-existent directory
 func TestFilesystemTool_ListDir_NotFound(t *testing.T) {
-	tool := &ListDirTool{}
+	tool := NewListDirTool("", false)
 	ctx := context.Background()
 	args := map[string]any{
 		"path": "/nonexistent_directory_12345",
@@ -237,7 +240,7 @@ func TestFilesystemTool_ListDir_NotFound(t *testing.T) {
 
 // TestFilesystemTool_ListDir_DefaultPath verifies default to current directory
 func TestFilesystemTool_ListDir_DefaultPath(t *testing.T) {
-	tool := &ListDirTool{}
+	tool := NewListDirTool("", false)
 	ctx := context.Background()
 	args := map[string]any{}
 
@@ -275,7 +278,211 @@ func TestFilesystemTool_ReadFile_RejectsSymlinkEscape(t *testing.T) {
 	if !result.IsError {
 		t.Fatalf("expected symlink escape to be blocked")
 	}
-	if !strings.Contains(result.ForLLM, "symlink resolves outside workspace") {
+	// os.Root might return different errors depending on platform/implementation
+	// but it definitely should error.
+	// Our wrapper returns "access denied or file not found"
+	if !strings.Contains(result.ForLLM, "access denied") && !strings.Contains(result.ForLLM, "file not found") &&
+		!strings.Contains(result.ForLLM, "no such file") {
 		t.Fatalf("expected symlink escape error, got: %s", result.ForLLM)
 	}
 }
+
+func TestFilesystemTool_EmptyWorkspace_AccessDenied(t *testing.T) {
+	tool := NewReadFileTool("", true) // restrict=true but workspace=""
+
+	// Try to read a sensitive file (simulated by a temp file outside workspace)
+	tmpDir := t.TempDir()
+	secretFile := filepath.Join(tmpDir, "shadow")
+	os.WriteFile(secretFile, []byte("secret data"), 0o600)
+
+	result := tool.Execute(context.Background(), map[string]any{
+		"path": secretFile,
+	})
+
+	// We EXPECT IsError=true (access blocked due to empty workspace)
+	assert.True(t, result.IsError, "Security Regression: Empty workspace allowed access! content: %s", result.ForLLM)
+
+	// Verify it failed for the right reason
+	assert.Contains(t, result.ForLLM, "workspace is not defined", "Expected 'workspace is not defined' error")
+}
+
+// TestRootMkdirAll verifies that root.MkdirAll (used by atomicWriteFileInRoot) handles all cases:
+// single dir, deeply nested dirs, already-existing dirs, and a file blocking a directory path.
+func TestRootMkdirAll(t *testing.T) {
+	workspace := t.TempDir()
+	root, err := os.OpenRoot(workspace)
+	if err != nil {
+		t.Fatalf("failed to open root: %v", err)
+	}
+	defer root.Close()
+
+	// Case 1: Single directory
+	err = root.MkdirAll("dir1", 0o755)
+	assert.NoError(t, err)
+	_, err = os.Stat(filepath.Join(workspace, "dir1"))
+	assert.NoError(t, err)
+
+	// Case 2: Deeply nested directory
+	err = root.MkdirAll("a/b/c/d", 0o755)
+	assert.NoError(t, err)
+	_, err = os.Stat(filepath.Join(workspace, "a/b/c/d"))
+	assert.NoError(t, err)
+
+	// Case 3: Already exists — must be idempotent
+	err = root.MkdirAll("a/b/c/d", 0o755)
+	assert.NoError(t, err)
+
+	// Case 4: A regular file blocks directory creation — must error
+	err = os.WriteFile(filepath.Join(workspace, "file_exists"), []byte("data"), 0o644)
+	assert.NoError(t, err)
+	err = root.MkdirAll("file_exists", 0o755)
+	assert.Error(t, err, "expected error when a file exists at the directory path")
+}
+
+func TestFilesystemTool_WriteFile_Restricted_CreateDir(t *testing.T) {
+	workspace := t.TempDir()
+	tool := NewWriteFileTool(workspace, true)
+	ctx := context.Background()
+
+	testFile := "deep/nested/path/to/file.txt"
+	content := "deep content"
+	args := map[string]any{
+		"path":    testFile,
+		"content": content,
+	}
+
+	result := tool.Execute(ctx, args)
+	assert.False(t, result.IsError, "Expected success, got: %s", result.ForLLM)
+
+	// Verify file content
+	actualPath := filepath.Join(workspace, testFile)
+	data, err := os.ReadFile(actualPath)
+	assert.NoError(t, err)
+	assert.Equal(t, content, string(data))
+}
+
+// TestHostRW_Read_PermissionDenied verifies that hostRW.Read surfaces access denied errors.
+func TestHostRW_Read_PermissionDenied(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("skipping permission test: running as root")
+	}
+	tmpDir := t.TempDir()
+	protected := filepath.Join(tmpDir, "protected.txt")
+	err := os.WriteFile(protected, []byte("secret"), 0o000)
+	assert.NoError(t, err)
+	defer os.Chmod(protected, 0o644) // ensure cleanup
+
+	_, err = (&hostFs{}).ReadFile(protected)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "access denied")
+}
+
+// TestHostRW_Read_Directory verifies that hostRW.Read returns an error when given a directory path.
+func TestHostRW_Read_Directory(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	_, err := (&hostFs{}).ReadFile(tmpDir)
+	assert.Error(t, err, "expected error when reading a directory as a file")
+}
+
+// TestRootRW_Read_Directory verifies that rootRW.Read returns an error when given a directory.
+func TestRootRW_Read_Directory(t *testing.T) {
+	workspace := t.TempDir()
+	root, err := os.OpenRoot(workspace)
+	assert.NoError(t, err)
+	defer root.Close()
+
+	// Create a subdirectory
+	err = root.Mkdir("subdir", 0o755)
+	assert.NoError(t, err)
+
+	_, err = (&sandboxFs{workspace: workspace}).ReadFile("subdir")
+	assert.Error(t, err, "expected error when reading a directory as a file")
+}
+
+// TestHostRW_Write_ParentDirMissing verifies that hostRW.Write creates parent dirs automatically.
+func TestHostRW_Write_ParentDirMissing(t *testing.T) {
+	tmpDir := t.TempDir()
+	target := filepath.Join(tmpDir, "a", "b", "c", "file.txt")
+
+	err := (&hostFs{}).WriteFile(target, []byte("hello"))
+	assert.NoError(t, err)
+
+	data, err := os.ReadFile(target)
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", string(data))
+}
+
+// TestRootRW_Write_ParentDirMissing verifies that rootRW.Write creates
+// nested parent directories automatically within the sandbox.
+func TestRootRW_Write_ParentDirMissing(t *testing.T) {
+	workspace := t.TempDir()
+
+	relPath := "x/y/z/file.txt"
+	err := (&sandboxFs{workspace: workspace}).WriteFile(relPath, []byte("nested"))
+	assert.NoError(t, err)
+
+	data, err := os.ReadFile(filepath.Join(workspace, relPath))
+	assert.NoError(t, err)
+	assert.Equal(t, "nested", string(data))
+}
+
+// TestHostRW_Write verifies the hostRW.Write helper function
+func TestHostRW_Write(t *testing.T) {
+	tmpDir := t.TempDir()
+	testFile := filepath.Join(tmpDir, "atomic_test.txt")
+	testData := []byte("atomic test content")
+
+	err := (&hostFs{}).WriteFile(testFile, testData)
+	assert.NoError(t, err)
+
+	content, err := os.ReadFile(testFile)
+	assert.NoError(t, err)
+	assert.Equal(t, testData, content)
+
+	// Verify it overwrites correctly
+	newData := []byte("new atomic content")
+	err = (&hostFs{}).WriteFile(testFile, newData)
+	assert.NoError(t, err)
+
+	content, err = os.ReadFile(testFile)
+	assert.NoError(t, err)
+	assert.Equal(t, newData, content)
+}
+
+// TestRootRW_Write verifies the rootRW.Write helper function
+func TestRootRW_Write(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	relPath := "atomic_root_test.txt"
+	testData := []byte("atomic root test content")
+
+	erw := &sandboxFs{workspace: tmpDir}
+	err := erw.WriteFile(relPath, testData)
+	assert.NoError(t, err)
+
+	root, err := os.OpenRoot(tmpDir)
+	assert.NoError(t, err)
+	defer root.Close()
+
+	f, err := root.Open(relPath)
+	assert.NoError(t, err)
+	defer f.Close()
+
+	content, err := io.ReadAll(f)
+	assert.NoError(t, err)
+	assert.Equal(t, testData, content)
+
+	// Verify it overwrites correctly
+	newData := []byte("new root atomic content")
+	err = erw.WriteFile(relPath, newData)
+	assert.NoError(t, err)
+
+	f2, err := root.Open(relPath)
+	assert.NoError(t, err)
+	defer f2.Close()
+
+	content, err = io.ReadAll(f2)
+	assert.NoError(t, err)
+	assert.Equal(t, newData, content)
+}

From 6d487a12b26ae2131a573915ee4f55a4da424c30 Mon Sep 17 00:00:00 2001
From: Zenix <zenixls2@gmail.com>
Date: Mon, 23 Feb 2026 19:29:43 +0900
Subject: [PATCH 21/52] fix: make install should be aware of the textfile busy
 since it tries to overwrite the file with non-atomic operation (#558)

---
 Makefile | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index a5ad4a02d..29e2fc964 100644
--- a/Makefile
+++ b/Makefile
@@ -24,6 +24,7 @@ GOLANGCI_LINT?=golangci-lint
 INSTALL_PREFIX?=$(HOME)/.local
 INSTALL_BIN_DIR=$(INSTALL_PREFIX)/bin
 INSTALL_MAN_DIR=$(INSTALL_PREFIX)/share/man/man1
+INSTALL_TMP_SUFFIX=.new
 
 # Workspace and Skills
 PICOCLAW_HOME?=$(HOME)/.picoclaw
@@ -99,8 +100,10 @@ build-all: generate
 install: build
 	@echo "Installing $(BINARY_NAME)..."
 	@mkdir -p $(INSTALL_BIN_DIR)
-	@cp $(BUILD_DIR)/$(BINARY_NAME) $(INSTALL_BIN_DIR)/$(BINARY_NAME)
-	@chmod +x $(INSTALL_BIN_DIR)/$(BINARY_NAME)
+	# Copy binary with temporary suffix to ensure atomic update
+	@cp $(BUILD_DIR)/$(BINARY_NAME) $(INSTALL_BIN_DIR)/$(BINARY_NAME)$(INSTALL_TMP_SUFFIX)
+	@chmod +x $(INSTALL_BIN_DIR)/$(BINARY_NAME)$(INSTALL_TMP_SUFFIX)
+	@mv -f $(INSTALL_BIN_DIR)/$(BINARY_NAME)$(INSTALL_TMP_SUFFIX) $(INSTALL_BIN_DIR)/$(BINARY_NAME)
 	@echo "Installed binary to $(INSTALL_BIN_DIR)/$(BINARY_NAME)"
 	@echo "Installation complete!"
 

From 8a53cb96651fad13c665417aadbedddf3e14a284 Mon Sep 17 00:00:00 2001
From: Chujiang <110hqc@gmail.com>
Date: Tue, 24 Feb 2026 05:52:16 +0800
Subject: [PATCH 22/52] fix: align Docker Go version with go.mod and optimize
 logger (#596)

- Update Dockerfile to use golang:1.25-alpine to match go.mod (go 1.25.7)
- Optimize logger by avoiding string concatenation in file writes
- Add explicit empty string assignment for fieldStr when no fields

These changes improve build consistency and reduce memory allocations
in the hot logging path, which is important for the project's goal
of running on resource-constrained devices (<10MB RAM).

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 Dockerfile           | 2 +-
 pkg/logger/logger.go | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0360cfda6..480244127 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,7 +1,7 @@
 # ============================================================
 # Stage 1: Build the picoclaw binary
 # ============================================================
-FROM golang:1.26.0-alpine AS builder
+FROM golang:1.25-alpine AS builder
 
 RUN apk add --no-cache git make
 
diff --git a/pkg/logger/logger.go b/pkg/logger/logger.go
index 54de66bf9..c14fbd464 100644
--- a/pkg/logger/logger.go
+++ b/pkg/logger/logger.go
@@ -119,13 +119,15 @@ func logMessage(level LogLevel, component string, message string, fields map[str
 	if logger.file != nil {
 		jsonData, err := json.Marshal(entry)
 		if err == nil {
-			logger.file.WriteString(string(jsonData) + "\n")
+			logger.file.Write(append(jsonData, '\n'))
 		}
 	}
 
 	var fieldStr string
 	if len(fields) > 0 {
 		fieldStr = " " + formatFields(fields)
+	} else {
+		fieldStr = ""
 	}
 
 	logLine := fmt.Sprintf("[%s] [%s]%s %s%s",

From 2fa51d7b868672ab2fd054396216fa68184b3ad6 Mon Sep 17 00:00:00 2001
From: 0x5487 <jawc@hotmail.com>
Date: Tue, 24 Feb 2026 05:54:10 +0800
Subject: [PATCH 23/52] fix(security): change gateway default bind to 127.0.0.1
 (#393)

* chore: Update default host bindings from 0.0.0.0 to 127.0.0.1 for various services and examples.

* config: Update default host bindings to 0.0.0.0 for improved Docker accessibility and add related documentation.

* chore: resolve conflict

* chore: remove link

* docs: Add a tip for Docker users regarding gateway host configuration to the French and Vietnamese READMEs.

* fix: typo issue

* docs: Update Chinese README.zh.md.
---
 README.fr.md               | 4 ++++
 README.ja.md               | 4 ++++
 README.md                  | 4 ++++
 README.pt-br.md            | 4 ++++
 README.vi.md               | 4 ++++
 README.zh.md               | 3 +++
 config/config.example.json | 2 +-
 pkg/config/config_test.go  | 4 ++--
 pkg/config/defaults.go     | 2 +-
 9 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/README.fr.md b/README.fr.md
index a762870ff..d09276c27 100644
--- a/README.fr.md
+++ b/README.fr.md
@@ -171,6 +171,10 @@ vim config/config.json      # Configurez DISCORD_BOT_TOKEN, clés API, etc.
 # 3. Compiler & Démarrer
 docker compose --profile gateway up -d
 
+> [!TIP]
+> **Utilisateurs Docker** : Par défaut, le Gateway écoute sur `127.0.0.1`, ce qui n'est pas accessible depuis l'hôte. Si vous avez besoin d'accéder aux endpoints de santé ou d'exposer des ports, définissez `PICOCLAW_GATEWAY_HOST=0.0.0.0` dans votre environnement ou mettez à jour `config.json`.
+
+
 # 4. Voir les logs
 docker compose logs -f picoclaw-gateway
 
diff --git a/README.ja.md b/README.ja.md
index 3506c77c2..67eccddc2 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -133,6 +133,10 @@ vim config/config.json      # DISCORD_BOT_TOKEN, プロバイダーの API キ
 # 3. ビルドと起動
 docker compose --profile gateway up -d
 
+> [!TIP]
+> **Docker ユーザー**: デフォルトでは、Gateway は `127.0.0.1` でリッスンしており、ホストからアクセスできません。ヘルスチェックエンドポイントにアクセスしたり、ポートを公開したりする必要がある場合は、環境変数で `PICOCLAW_GATEWAY_HOST=0.0.0.0` を設定するか、`config.json` を更新してください。
+
+
 # 4. ログ確認
 docker compose logs -f picoclaw-gateway
 
diff --git a/README.md b/README.md
index 955255f2e..84d92115b 100644
--- a/README.md
+++ b/README.md
@@ -171,6 +171,10 @@ vim config/config.json      # Set DISCORD_BOT_TOKEN, API keys, etc.
 # 3. Build & Start
 docker compose --profile gateway up -d
 
+> [!TIP]
+> **Docker Users**: By default, the Gateway listens on `127.0.0.1` which is not accessible from the host. If you need to access the health endpoints or expose ports, set `PICOCLAW_GATEWAY_HOST=0.0.0.0` in your environment or update `config.json`.
+
+
 # 4. Check logs
 docker compose logs -f picoclaw-gateway
 
diff --git a/README.pt-br.md b/README.pt-br.md
index 900ee7932..8d87333bc 100644
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -172,6 +172,10 @@ vim config/config.json      # Configure DISCORD_BOT_TOKEN, API keys, etc.
 # 3. Build & Iniciar
 docker compose --profile gateway up -d
 
+> [!TIP]
+> **Usuários Docker**: Por padrão, o Gateway ouve em `127.0.0.1`, o que não é acessível a partir do host. Se você precisar acessar os endpoints de integridade ou expor portas, defina `PICOCLAW_GATEWAY_HOST=0.0.0.0` em seu ambiente ou atualize o `config.json`.
+
+
 # 4. Ver logs
 docker compose logs -f picoclaw-gateway
 
diff --git a/README.vi.md b/README.vi.md
index 29ff12bb0..1be58d9f6 100644
--- a/README.vi.md
+++ b/README.vi.md
@@ -152,6 +152,10 @@ vim config/config.json      # Thiết lập DISCORD_BOT_TOKEN, API keys, v.v.
 # 3. Build & Khởi động
 docker compose --profile gateway up -d
 
+> [!TIP]
+> **Người dùng Docker**: Theo mặc định, Gateway lắng nghe trên `127.0.0.1`, không thể truy cập từ máy chủ. Nếu bạn cần truy cập các endpoint kiểm tra sức khỏe hoặc mở cổng, hãy đặt `PICOCLAW_GATEWAY_HOST=0.0.0.0` trong môi trường của bạn hoặc cập nhật `config.json`.
+
+
 # 4. Xem logs
 docker compose logs -f picoclaw-gateway
 
diff --git a/README.zh.md b/README.zh.md
index 17a736fec..74760b3b1 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -173,6 +173,9 @@ vim config/config.json      # 设置 DISCORD_BOT_TOKEN, API keys 等
 # 3. 构建并启动
 docker compose --profile gateway up -d
 
+> [!TIP]
+**Docker 用户**: 默认情况下, Gateway监听 `127.0.0.1`，这使得这个端口未暴露到容器外。如果你需要通过端口映射访问健康检查接口, 请在环境变量中设置 `PICOCLAW_GATEWAY_HOST=0.0.0.0` 或修改 `config.json`。
+
 # 4. 查看日志
 docker compose logs -f picoclaw-gateway
 
diff --git a/config/config.example.json b/config/config.example.json
index e814fcbb8..555509732 100644
--- a/config/config.example.json
+++ b/config/config.example.json
@@ -247,7 +247,7 @@
     "monitor_usb": true
   },
   "gateway": {
-    "host": "0.0.0.0",
+    "host": "127.0.0.1",
     "port": 18790
   }
 }
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
index 0898217d6..f88c0269c 100644
--- a/pkg/config/config_test.go
+++ b/pkg/config/config_test.go
@@ -246,7 +246,7 @@ func TestDefaultConfig_Temperature(t *testing.T) {
 func TestDefaultConfig_Gateway(t *testing.T) {
 	cfg := DefaultConfig()
 
-	if cfg.Gateway.Host != "0.0.0.0" {
+	if cfg.Gateway.Host != "127.0.0.1" {
 		t.Error("Gateway host should have default value")
 	}
 	if cfg.Gateway.Port == 0 {
@@ -343,7 +343,7 @@ func TestConfig_Complete(t *testing.T) {
 	if cfg.Agents.Defaults.MaxToolIterations == 0 {
 		t.Error("MaxToolIterations should not be zero")
 	}
-	if cfg.Gateway.Host != "0.0.0.0" {
+	if cfg.Gateway.Host != "127.0.0.1" {
 		t.Error("Gateway host should have default value")
 	}
 	if cfg.Gateway.Port == 0 {
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index 065273c28..b96ee4d89 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -272,7 +272,7 @@ func DefaultConfig() *Config {
 			},
 		},
 		Gateway: GatewayConfig{
-			Host: "0.0.0.0",
+			Host: "127.0.0.1",
 			Port: 18790,
 		},
 		Tools: ToolsConfig{

From 09b1992dd79cac46b7a48176074eabae36b9c1bc Mon Sep 17 00:00:00 2001
From: Goksu Ceylan <79890826+GoCeylan@users.noreply.github.com>
Date: Mon, 23 Feb 2026 17:02:44 -0500
Subject: [PATCH 24/52] fix(security): ensure custom deny patterns extend
 defaults instead of replacing them (#479)

* fix (security): custom deny patterns denying default patterns

* fix formatting whitespace
---
 pkg/tools/shell.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pkg/tools/shell.go b/pkg/tools/shell.go
index a1ee0b6e1..6883172cd 100644
--- a/pkg/tools/shell.go
+++ b/pkg/tools/shell.go
@@ -81,6 +81,7 @@ func NewExecToolWithConfig(workingDir string, restrict bool, config *config.Conf
 		execConfig := config.Tools.Exec
 		enableDenyPatterns = execConfig.EnableDenyPatterns
 		if enableDenyPatterns {
+			denyPatterns = append(denyPatterns, defaultDenyPatterns...)
 			if len(execConfig.CustomDenyPatterns) > 0 {
 				fmt.Printf("Using custom deny patterns: %v\n", execConfig.CustomDenyPatterns)
 				for _, pattern := range execConfig.CustomDenyPatterns {
@@ -91,8 +92,6 @@ func NewExecToolWithConfig(workingDir string, restrict bool, config *config.Conf
 					}
 					denyPatterns = append(denyPatterns, re)
 				}
-			} else {
-				denyPatterns = append(denyPatterns, defaultDenyPatterns...)
 			}
 		} else {
 			// If deny patterns are disabled, we won't add any patterns, allowing all commands.

From 6fe3920a4d836b97c838fd39874cc6a5d07d1d40 Mon Sep 17 00:00:00 2001
From: mattn <mattn.jp@gmail.com>
Date: Tue, 24 Feb 2026 08:07:09 +0900
Subject: [PATCH 25/52] perf: refactoring collecting skills (#688)

* perf: refactoring collecting skills

* Fix order to store dir.Name()

* Add tests
---
 pkg/skills/loader.go      | 140 +++++++++++---------------------------
 pkg/skills/loader_test.go | 131 +++++++++++++++++++++++++++++++++++
 2 files changed, 170 insertions(+), 101 deletions(-)

diff --git a/pkg/skills/loader.go b/pkg/skills/loader.go
index eb0d5f322..f4f55a698 100644
--- a/pkg/skills/loader.go
+++ b/pkg/skills/loader.go
@@ -71,112 +71,50 @@ func NewSkillsLoader(workspace string, globalSkills string, builtinSkills string
 
 func (sl *SkillsLoader) ListSkills() []SkillInfo {
 	skills := make([]SkillInfo, 0)
+	seen := make(map[string]bool)
 
-	if sl.workspaceSkills != "" {
-		if dirs, err := os.ReadDir(sl.workspaceSkills); err == nil {
-			for _, dir := range dirs {
-				if dir.IsDir() {
-					skillFile := filepath.Join(sl.workspaceSkills, dir.Name(), "SKILL.md")
-					if _, err := os.Stat(skillFile); err == nil {
-						info := SkillInfo{
-							Name:   dir.Name(),
-							Path:   skillFile,
-							Source: "workspace",
-						}
-						metadata := sl.getSkillMetadata(skillFile)
-						if metadata != nil {
-							info.Description = metadata.Description
-							info.Name = metadata.Name
-						}
-						if err := info.validate(); err != nil {
-							slog.Warn("invalid skill from workspace", "name", info.Name, "error", err)
-							continue
-						}
-						skills = append(skills, info)
-					}
-				}
+	addSkills := func(dir, source string) {
+		if dir == "" {
+			return
+		}
+		dirs, err := os.ReadDir(dir)
+		if err != nil {
+			return
+		}
+		for _, d := range dirs {
+			if !d.IsDir() {
+				continue
 			}
+			skillFile := filepath.Join(dir, d.Name(), "SKILL.md")
+			if _, err := os.Stat(skillFile); err != nil {
+				continue
+			}
+			info := SkillInfo{
+				Name:   d.Name(),
+				Path:   skillFile,
+				Source: source,
+			}
+			metadata := sl.getSkillMetadata(skillFile)
+			if metadata != nil {
+				info.Description = metadata.Description
+				info.Name = metadata.Name
+			}
+			if err := info.validate(); err != nil {
+				slog.Warn("invalid skill from "+source, "name", info.Name, "error", err)
+				continue
+			}
+			if seen[info.Name] {
+				continue
+			}
+			seen[info.Name] = true
+			skills = append(skills, info)
 		}
 	}
 
-	// 全局 skills (~/.picoclaw/skills) - 被 workspace skills 覆盖
-	if sl.globalSkills != "" {
-		if dirs, err := os.ReadDir(sl.globalSkills); err == nil {
-			for _, dir := range dirs {
-				if dir.IsDir() {
-					skillFile := filepath.Join(sl.globalSkills, dir.Name(), "SKILL.md")
-					if _, err := os.Stat(skillFile); err == nil {
-						// 检查是否已被 workspace skills 覆盖
-						exists := false
-						for _, s := range skills {
-							if s.Name == dir.Name() && s.Source == "workspace" {
-								exists = true
-								break
-							}
-						}
-						if exists {
-							continue
-						}
-
-						info := SkillInfo{
-							Name:   dir.Name(),
-							Path:   skillFile,
-							Source: "global",
-						}
-						metadata := sl.getSkillMetadata(skillFile)
-						if metadata != nil {
-							info.Description = metadata.Description
-							info.Name = metadata.Name
-						}
-						if err := info.validate(); err != nil {
-							slog.Warn("invalid skill from global", "name", info.Name, "error", err)
-							continue
-						}
-						skills = append(skills, info)
-					}
-				}
-			}
-		}
-	}
-
-	if sl.builtinSkills != "" {
-		if dirs, err := os.ReadDir(sl.builtinSkills); err == nil {
-			for _, dir := range dirs {
-				if dir.IsDir() {
-					skillFile := filepath.Join(sl.builtinSkills, dir.Name(), "SKILL.md")
-					if _, err := os.Stat(skillFile); err == nil {
-						// 检查是否已被 workspace 或 global skills 覆盖
-						exists := false
-						for _, s := range skills {
-							if s.Name == dir.Name() && (s.Source == "workspace" || s.Source == "global") {
-								exists = true
-								break
-							}
-						}
-						if exists {
-							continue
-						}
-
-						info := SkillInfo{
-							Name:   dir.Name(),
-							Path:   skillFile,
-							Source: "builtin",
-						}
-						metadata := sl.getSkillMetadata(skillFile)
-						if metadata != nil {
-							info.Description = metadata.Description
-							info.Name = metadata.Name
-						}
-						if err := info.validate(); err != nil {
-							slog.Warn("invalid skill from builtin", "name", info.Name, "error", err)
-							continue
-						}
-						skills = append(skills, info)
-					}
-				}
-			}
-		}
-	}
+	// Priority: workspace > global > builtin
+	addSkills(sl.workspaceSkills, "workspace")
+	addSkills(sl.globalSkills, "global")
+	addSkills(sl.builtinSkills, "builtin")
 
 	return skills
 }
diff --git a/pkg/skills/loader_test.go b/pkg/skills/loader_test.go
index aca901d33..9428bea62 100644
--- a/pkg/skills/loader_test.go
+++ b/pkg/skills/loader_test.go
@@ -1,9 +1,12 @@
 package skills
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSkillsInfoValidate(t *testing.T) {
@@ -135,6 +138,134 @@ func TestExtractFrontmatter(t *testing.T) {
 	}
 }
 
+// createSkillDir creates a skill directory with a SKILL.md file containing the given frontmatter.
+func createSkillDir(t *testing.T, base, dirName, name, description string) {
+	t.Helper()
+	dir := filepath.Join(base, dirName)
+	require.NoError(t, os.MkdirAll(dir, 0o755))
+	content := "---\nname: " + name + "\ndescription: " + description + "\n---\n\n# " + name
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte(content), 0o644))
+}
+
+func TestListSkillsWorkspaceOverridesGlobal(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+
+	createSkillDir(t, filepath.Join(ws, "skills"), "my-skill", "my-skill", "workspace version")
+	createSkillDir(t, global, "my-skill", "my-skill", "global version")
+
+	sl := NewSkillsLoader(ws, global, "")
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 1)
+	assert.Equal(t, "workspace", skills[0].Source)
+	assert.Equal(t, "workspace version", skills[0].Description)
+}
+
+func TestListSkillsGlobalOverridesBuiltin(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+	builtin := filepath.Join(tmp, "builtin")
+
+	createSkillDir(t, global, "my-skill", "my-skill", "global version")
+	createSkillDir(t, builtin, "my-skill", "my-skill", "builtin version")
+
+	sl := NewSkillsLoader(ws, global, builtin)
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 1)
+	assert.Equal(t, "global", skills[0].Source)
+	assert.Equal(t, "global version", skills[0].Description)
+}
+
+func TestListSkillsMetadataNameDedup(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+
+	// Different directory names but same metadata name
+	createSkillDir(t, filepath.Join(ws, "skills"), "dir-a", "shared-name", "workspace version")
+	createSkillDir(t, global, "dir-b", "shared-name", "global version")
+
+	sl := NewSkillsLoader(ws, global, "")
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 1)
+	assert.Equal(t, "shared-name", skills[0].Name)
+	assert.Equal(t, "workspace", skills[0].Source)
+}
+
+func TestListSkillsMultipleDistinctSkills(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+	builtin := filepath.Join(tmp, "builtin")
+
+	createSkillDir(t, filepath.Join(ws, "skills"), "skill-a", "skill-a", "desc a")
+	createSkillDir(t, global, "skill-b", "skill-b", "desc b")
+	createSkillDir(t, builtin, "skill-c", "skill-c", "desc c")
+
+	sl := NewSkillsLoader(ws, global, builtin)
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 3)
+	names := map[string]string{}
+	for _, s := range skills {
+		names[s.Name] = s.Source
+	}
+	assert.Equal(t, "workspace", names["skill-a"])
+	assert.Equal(t, "global", names["skill-b"])
+	assert.Equal(t, "builtin", names["skill-c"])
+}
+
+func TestListSkillsInvalidSkillSkipped(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+
+	// Invalid name (underscore)
+	createSkillDir(t, filepath.Join(ws, "skills"), "bad_skill", "bad_skill", "desc")
+	// Valid skill
+	createSkillDir(t, global, "good-skill", "good-skill", "desc")
+
+	sl := NewSkillsLoader(ws, global, "")
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 1)
+	assert.Equal(t, "good-skill", skills[0].Name)
+}
+
+func TestListSkillsEmptyAndNonexistentDirs(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	emptyDir := filepath.Join(tmp, "empty")
+	require.NoError(t, os.MkdirAll(emptyDir, 0o755))
+
+	sl := NewSkillsLoader(ws, emptyDir, filepath.Join(tmp, "nonexistent"))
+	skills := sl.ListSkills()
+
+	assert.Empty(t, skills)
+}
+
+func TestListSkillsDirWithoutSkillMD(t *testing.T) {
+	tmp := t.TempDir()
+	ws := filepath.Join(tmp, "workspace")
+	global := filepath.Join(tmp, "global")
+
+	// Directory exists but has no SKILL.md
+	require.NoError(t, os.MkdirAll(filepath.Join(global, "no-skillmd"), 0o755))
+	// Valid skill alongside
+	createSkillDir(t, global, "real-skill", "real-skill", "desc")
+
+	sl := NewSkillsLoader(ws, global, "")
+	skills := sl.ListSkills()
+
+	assert.Len(t, skills, 1)
+	assert.Equal(t, "real-skill", skills[0].Name)
+}
+
 func TestStripFrontmatter(t *testing.T) {
 	sl := &SkillsLoader{}
 

From 6fb61539d779dd155ba82422fe7d0f1094f0893e Mon Sep 17 00:00:00 2001
From: Kai Xia <kaix+github@fastmail.com>
Date: Tue, 24 Feb 2026 10:27:49 +1100
Subject: [PATCH 26/52] translate Chinese comments

Signed-off-by: Kai Xia <kaix+github@fastmail.com>
---
 cmd/picoclaw/main.go     |  2 +-
 pkg/channels/qq.go       | 46 ++++++++++++++++++++--------------------
 pkg/channels/slack.go    |  6 +++---
 pkg/channels/telegram.go |  6 +++---
 pkg/skills/loader.go     | 12 +++++------
 5 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/cmd/picoclaw/main.go b/cmd/picoclaw/main.go
index 1e4b393f8..25ad701ca 100644
--- a/cmd/picoclaw/main.go
+++ b/cmd/picoclaw/main.go
@@ -131,7 +131,7 @@ func main() {
 
 		workspace := cfg.WorkspacePath()
 		installer := skills.NewSkillInstaller(workspace)
-		// 获取全局配置目录和内置 skills 目录
+		// get global config directory and builtin skills directory
 		globalDir := filepath.Dir(getConfigPath())
 		globalSkillsDir := filepath.Join(globalDir, "skills")
 		builtinSkillsDir := filepath.Join(globalDir, "picoclaw", "skills")
diff --git a/pkg/channels/qq.go b/pkg/channels/qq.go
index e66cac533..b10776db6 100644
--- a/pkg/channels/qq.go
+++ b/pkg/channels/qq.go
@@ -47,31 +47,31 @@ func (c *QQChannel) Start(ctx context.Context) error {
 
 	logger.InfoC("qq", "Starting QQ bot (WebSocket mode)")
 
-	// 创建 token source
+	// create token source
 	credentials := &token.QQBotCredentials{
 		AppID:     c.config.AppID,
 		AppSecret: c.config.AppSecret,
 	}
 	c.tokenSource = token.NewQQBotTokenSource(credentials)
 
-	// 创建子 context
+	// create child context
 	c.ctx, c.cancel = context.WithCancel(ctx)
 
-	// 启动自动刷新 token 协程
+	// start auto-refresh token goroutine
 	if err := token.StartRefreshAccessToken(c.ctx, c.tokenSource); err != nil {
 		return fmt.Errorf("failed to start token refresh: %w", err)
 	}
 
-	// 初始化 OpenAPI 客户端
+	// initialize OpenAPI client
 	c.api = botgo.NewOpenAPI(c.config.AppID, c.tokenSource).WithTimeout(5 * time.Second)
 
-	// 注册事件处理器
+	// register event handlers
 	intent := event.RegisterHandlers(
 		c.handleC2CMessage(),
 		c.handleGroupATMessage(),
 	)
 
-	// 获取 WebSocket 接入点
+	// get WebSocket endpoint
 	wsInfo, err := c.api.WS(c.ctx, nil, "")
 	if err != nil {
 		return fmt.Errorf("failed to get websocket info: %w", err)
@@ -81,10 +81,10 @@ func (c *QQChannel) Start(ctx context.Context) error {
 		"shards": wsInfo.Shards,
 	})
 
-	// 创建并保存 sessionManager
+	// create and save sessionManager
 	c.sessionManager = botgo.NewSessionManager()
 
-	// 在 goroutine 中启动 WebSocket 连接，避免阻塞
+	// start WebSocket connection in goroutine to avoid blocking
 	go func() {
 		if err := c.sessionManager.Start(wsInfo, c.tokenSource, &intent); err != nil {
 			logger.ErrorCF("qq", "WebSocket session error", map[string]any{
@@ -116,12 +116,12 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 		return fmt.Errorf("QQ bot not running")
 	}
 
-	// 构造消息
+	// construct message
 	msgToCreate := &dto.MessageToCreate{
 		Content: msg.Content,
 	}
 
-	// C2C 消息发送
+	// send C2C message
 	_, err := c.api.PostC2CMessage(ctx, msg.ChatID, msgToCreate)
 	if err != nil {
 		logger.ErrorCF("qq", "Failed to send C2C message", map[string]any{
@@ -133,15 +133,15 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	return nil
 }
 
-// handleC2CMessage 处理 QQ 私聊消息
+// handleC2CMessage handles QQ private messages
 func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 	return func(event *dto.WSPayload, data *dto.WSC2CMessageData) error {
-		// 去重检查
+		// deduplication check
 		if c.isDuplicate(data.ID) {
 			return nil
 		}
 
-		// 提取用户信息
+		// extract user info
 		var senderID string
 		if data.Author != nil && data.Author.ID != "" {
 			senderID = data.Author.ID
@@ -150,7 +150,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 			return nil
 		}
 
-		// 提取消息内容
+		// extract message content
 		content := data.Content
 		if content == "" {
 			logger.DebugC("qq", "Received empty message, ignoring")
@@ -162,7 +162,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 			"length": len(content),
 		})
 
-		// 转发到消息总线
+		// forward to message bus
 		metadata := map[string]string{
 			"message_id": data.ID,
 			"peer_kind":  "direct",
@@ -175,15 +175,15 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 	}
 }
 
-// handleGroupATMessage 处理群@消息
+// handleGroupATMessage handles group @messages
 func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 	return func(event *dto.WSPayload, data *dto.WSGroupATMessageData) error {
-		// 去重检查
+		// deduplication check
 		if c.isDuplicate(data.ID) {
 			return nil
 		}
 
-		// 提取用户信息
+		// extract user info
 		var senderID string
 		if data.Author != nil && data.Author.ID != "" {
 			senderID = data.Author.ID
@@ -192,7 +192,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			return nil
 		}
 
-		// 提取消息内容（去掉 @ 机器人部分）
+		// extract message content (remove @bot part)
 		content := data.Content
 		if content == "" {
 			logger.DebugC("qq", "Received empty group message, ignoring")
@@ -205,7 +205,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			"length": len(content),
 		})
 
-		// 转发到消息总线（使用 GroupID 作为 ChatID）
+		// forward to message bus (use GroupID as ChatID)
 		metadata := map[string]string{
 			"message_id": data.ID,
 			"group_id":   data.GroupID,
@@ -219,7 +219,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 	}
 }
 
-// isDuplicate 检查消息是否重复
+// isDuplicate checks if message is duplicate
 func (c *QQChannel) isDuplicate(messageID string) bool {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -230,9 +230,9 @@ func (c *QQChannel) isDuplicate(messageID string) bool {
 
 	c.processedIDs[messageID] = true
 
-	// 简单清理：限制 map 大小
+	// simple cleanup: limit map size
 	if len(c.processedIDs) > 10000 {
-		// 清空一半
+		// clear half
 		count := 0
 		for id := range c.processedIDs {
 			if count >= 5000 {
diff --git a/pkg/channels/slack.go b/pkg/channels/slack.go
index f7359cd6d..f087aa8da 100644
--- a/pkg/channels/slack.go
+++ b/pkg/channels/slack.go
@@ -200,7 +200,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		return
 	}
 
-	// 检查白名单，避免为被拒绝的用户下载附件
+	// check allowlist to avoid downloading attachments for rejected users
 	if !c.IsAllowed(ev.User) {
 		logger.DebugCF("slack", "Message rejected by allowlist", map[string]any{
 			"user_id": ev.User,
@@ -232,9 +232,9 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 	content = c.stripBotMention(content)
 
 	var mediaPaths []string
-	localFiles := []string{} // 跟踪需要清理的本地文件
+	localFiles := []string{} // track local files that need cleanup
 
-	// 确保临时文件在函数返回时被清理
+	// ensure temp files are cleaned up when function returns
 	defer func() {
 		for _, file := range localFiles {
 			if err := os.Remove(file); err != nil {
diff --git a/pkg/channels/telegram.go b/pkg/channels/telegram.go
index a0a1c8d0a..5cd51e8bc 100644
--- a/pkg/channels/telegram.go
+++ b/pkg/channels/telegram.go
@@ -208,7 +208,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		senderID = fmt.Sprintf("%d|%s", user.ID, user.Username)
 	}
 
-	// 检查白名单，避免为被拒绝的用户下载附件
+	// check allowlist to avoid downloading attachments for rejected users
 	if !c.IsAllowed(senderID) {
 		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]any{
 			"user_id": senderID,
@@ -221,9 +221,9 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 
 	content := ""
 	mediaPaths := []string{}
-	localFiles := []string{} // 跟踪需要清理的本地文件
+	localFiles := []string{} // track local files that need cleanup
 
-	// 确保临时文件在函数返回时被清理
+	// ensure temp files are cleaned up when function returns
 	defer func() {
 		for _, file := range localFiles {
 			if err := os.Remove(file); err != nil {
diff --git a/pkg/skills/loader.go b/pkg/skills/loader.go
index f4f55a698..5749d8983 100644
--- a/pkg/skills/loader.go
+++ b/pkg/skills/loader.go
@@ -55,9 +55,9 @@ func (info SkillInfo) validate() error {
 
 type SkillsLoader struct {
 	workspace       string
-	workspaceSkills string // workspace skills (项目级别)
-	globalSkills    string // 全局 skills (~/.picoclaw/skills)
-	builtinSkills   string // 内置 skills
+	workspaceSkills string // workspace skills (project-level)
+	globalSkills    string // global skills (~/.picoclaw/skills)
+	builtinSkills   string // builtin skills
 }
 
 func NewSkillsLoader(workspace string, globalSkills string, builtinSkills string) *SkillsLoader {
@@ -120,7 +120,7 @@ func (sl *SkillsLoader) ListSkills() []SkillInfo {
 }
 
 func (sl *SkillsLoader) LoadSkill(name string) (string, bool) {
-	// 1. 优先从 workspace skills 加载（项目级别）
+	// 1. load from workspace skills first (project-level)
 	if sl.workspaceSkills != "" {
 		skillFile := filepath.Join(sl.workspaceSkills, name, "SKILL.md")
 		if content, err := os.ReadFile(skillFile); err == nil {
@@ -128,7 +128,7 @@ func (sl *SkillsLoader) LoadSkill(name string) (string, bool) {
 		}
 	}
 
-	// 2. 其次从全局 skills 加载 (~/.picoclaw/skills)
+	// 2. then load from global skills (~/.picoclaw/skills)
 	if sl.globalSkills != "" {
 		skillFile := filepath.Join(sl.globalSkills, name, "SKILL.md")
 		if content, err := os.ReadFile(skillFile); err == nil {
@@ -136,7 +136,7 @@ func (sl *SkillsLoader) LoadSkill(name string) (string, bool) {
 		}
 	}
 
-	// 3. 最后从内置 skills 加载
+	// 3. finally load from builtin skills
 	if sl.builtinSkills != "" {
 		skillFile := filepath.Join(sl.builtinSkills, name, "SKILL.md")
 		if content, err := os.ReadFile(skillFile); err == nil {

From 57c1d37c22b5c18ee0b1b055966d2673744b98ab Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Fri, 20 Feb 2026 23:18:46 +0800
Subject: [PATCH 27/52] refactor(channels): add factory registry and export
 SetRunning on BaseChannel

---
 pkg/channels/base.go     |  4 ++++
 pkg/channels/registry.go | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 pkg/channels/registry.go

diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index cd6419ebb..3f0a766ea 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -101,3 +101,7 @@ func (c *BaseChannel) HandleMessage(senderID, chatID, content string, media []st
 func (c *BaseChannel) setRunning(running bool) {
 	c.running = running
 }
+
+func (c *BaseChannel) SetRunning(running bool) {
+	c.running = running
+}
diff --git a/pkg/channels/registry.go b/pkg/channels/registry.go
new file mode 100644
index 000000000..36a05bf3e
--- /dev/null
+++ b/pkg/channels/registry.go
@@ -0,0 +1,32 @@
+package channels
+
+import (
+	"sync"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+// ChannelFactory is a constructor function that creates a Channel from config and message bus.
+// Each channel subpackage registers one or more factories via init().
+type ChannelFactory func(cfg *config.Config, bus *bus.MessageBus) (Channel, error)
+
+var (
+	factoriesMu sync.RWMutex
+	factories   = map[string]ChannelFactory{}
+)
+
+// RegisterFactory registers a named channel factory. Called from subpackage init() functions.
+func RegisterFactory(name string, f ChannelFactory) {
+	factoriesMu.Lock()
+	defer factoriesMu.Unlock()
+	factories[name] = f
+}
+
+// getFactory looks up a channel factory by name.
+func getFactory(name string) (ChannelFactory, bool) {
+	factoriesMu.RLock()
+	defer factoriesMu.RUnlock()
+	f, ok := factories[name]
+	return f, ok
+}

From 383687dc57e93c33b4cfea2f669ba5eb3f4349d4 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Fri, 20 Feb 2026 23:19:40 +0800
Subject: [PATCH 28/52] refactor(channels): replace direct constructors with
 factory registry in manager

---
 pkg/channels/manager.go | 178 +++++++++++-----------------------------
 1 file changed, 48 insertions(+), 130 deletions(-)

diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 75edaf49e..091982282 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -43,166 +43,84 @@ func NewManager(cfg *config.Config, messageBus *bus.MessageBus) (*Manager, error
 	return m, nil
 }
 
+// initChannel is a helper that looks up a factory by name and creates the channel.
+func (m *Manager) initChannel(name, displayName string) {
+	f, ok := getFactory(name)
+	if !ok {
+		logger.WarnCF("channels", "Factory not registered", map[string]interface{}{
+			"channel": displayName,
+		})
+		return
+	}
+	logger.DebugCF("channels", "Attempting to initialize channel", map[string]interface{}{
+		"channel": displayName,
+	})
+	ch, err := f(m.config, m.bus)
+	if err != nil {
+		logger.ErrorCF("channels", "Failed to initialize channel", map[string]interface{}{
+			"channel": displayName,
+			"error":   err.Error(),
+		})
+	} else {
+		m.channels[name] = ch
+		logger.InfoCF("channels", "Channel enabled successfully", map[string]interface{}{
+			"channel": displayName,
+		})
+	}
+}
+
 func (m *Manager) initChannels() error {
 	logger.InfoC("channels", "Initializing channel manager")
 
 	if m.config.Channels.Telegram.Enabled && m.config.Channels.Telegram.Token != "" {
-		logger.DebugC("channels", "Attempting to initialize Telegram channel")
-		telegram, err := NewTelegramChannel(m.config, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize Telegram channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["telegram"] = telegram
-			logger.InfoC("channels", "Telegram channel enabled successfully")
-		}
+		m.initChannel("telegram", "Telegram")
 	}
 
 	if m.config.Channels.WhatsApp.Enabled && m.config.Channels.WhatsApp.BridgeURL != "" {
-		logger.DebugC("channels", "Attempting to initialize WhatsApp channel")
-		whatsapp, err := NewWhatsAppChannel(m.config.Channels.WhatsApp, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize WhatsApp channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["whatsapp"] = whatsapp
-			logger.InfoC("channels", "WhatsApp channel enabled successfully")
-		}
+		m.initChannel("whatsapp", "WhatsApp")
 	}
 
 	if m.config.Channels.Feishu.Enabled {
-		logger.DebugC("channels", "Attempting to initialize Feishu channel")
-		feishu, err := NewFeishuChannel(m.config.Channels.Feishu, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize Feishu channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["feishu"] = feishu
-			logger.InfoC("channels", "Feishu channel enabled successfully")
-		}
+		m.initChannel("feishu", "Feishu")
 	}
 
 	if m.config.Channels.Discord.Enabled && m.config.Channels.Discord.Token != "" {
-		logger.DebugC("channels", "Attempting to initialize Discord channel")
-		discord, err := NewDiscordChannel(m.config.Channels.Discord, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize Discord channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["discord"] = discord
-			logger.InfoC("channels", "Discord channel enabled successfully")
-		}
+		m.initChannel("discord", "Discord")
 	}
 
 	if m.config.Channels.MaixCam.Enabled {
-		logger.DebugC("channels", "Attempting to initialize MaixCam channel")
-		maixcam, err := NewMaixCamChannel(m.config.Channels.MaixCam, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize MaixCam channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["maixcam"] = maixcam
-			logger.InfoC("channels", "MaixCam channel enabled successfully")
-		}
+		m.initChannel("maixcam", "MaixCam")
 	}
 
 	if m.config.Channels.QQ.Enabled {
-		logger.DebugC("channels", "Attempting to initialize QQ channel")
-		qq, err := NewQQChannel(m.config.Channels.QQ, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize QQ channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["qq"] = qq
-			logger.InfoC("channels", "QQ channel enabled successfully")
-		}
+		m.initChannel("qq", "QQ")
 	}
 
 	if m.config.Channels.DingTalk.Enabled && m.config.Channels.DingTalk.ClientID != "" {
-		logger.DebugC("channels", "Attempting to initialize DingTalk channel")
-		dingtalk, err := NewDingTalkChannel(m.config.Channels.DingTalk, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize DingTalk channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["dingtalk"] = dingtalk
-			logger.InfoC("channels", "DingTalk channel enabled successfully")
-		}
+		m.initChannel("dingtalk", "DingTalk")
 	}
 
 	if m.config.Channels.Slack.Enabled && m.config.Channels.Slack.BotToken != "" {
-		logger.DebugC("channels", "Attempting to initialize Slack channel")
-		slackCh, err := NewSlackChannel(m.config.Channels.Slack, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize Slack channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["slack"] = slackCh
-			logger.InfoC("channels", "Slack channel enabled successfully")
-		}
+		m.initChannel("slack", "Slack")
 	}
 
 	if m.config.Channels.LINE.Enabled && m.config.Channels.LINE.ChannelAccessToken != "" {
-		logger.DebugC("channels", "Attempting to initialize LINE channel")
-		line, err := NewLINEChannel(m.config.Channels.LINE, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize LINE channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["line"] = line
-			logger.InfoC("channels", "LINE channel enabled successfully")
-		}
+		m.initChannel("line", "LINE")
 	}
 
 	if m.config.Channels.OneBot.Enabled && m.config.Channels.OneBot.WSUrl != "" {
-		logger.DebugC("channels", "Attempting to initialize OneBot channel")
-		onebot, err := NewOneBotChannel(m.config.Channels.OneBot, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize OneBot channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["onebot"] = onebot
-			logger.InfoC("channels", "OneBot channel enabled successfully")
-		}
+		m.initChannel("onebot", "OneBot")
 	}
 
 	if m.config.Channels.WeCom.Enabled && m.config.Channels.WeCom.Token != "" {
-		logger.DebugC("channels", "Attempting to initialize WeCom channel")
-		wecom, err := NewWeComBotChannel(m.config.Channels.WeCom, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize WeCom channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["wecom"] = wecom
-			logger.InfoC("channels", "WeCom channel enabled successfully")
-		}
+		m.initChannel("wecom", "WeCom")
 	}
 
 	if m.config.Channels.WeComApp.Enabled && m.config.Channels.WeComApp.CorpID != "" {
-		logger.DebugC("channels", "Attempting to initialize WeCom App channel")
-		wecomApp, err := NewWeComAppChannel(m.config.Channels.WeComApp, m.bus)
-		if err != nil {
-			logger.ErrorCF("channels", "Failed to initialize WeCom App channel", map[string]any{
-				"error": err.Error(),
-			})
-		} else {
-			m.channels["wecom_app"] = wecomApp
-			logger.InfoC("channels", "WeCom App channel enabled successfully")
-		}
+		m.initChannel("wecom_app", "WeCom App")
 	}
 
-	logger.InfoCF("channels", "Channel initialization completed", map[string]any{
+	logger.InfoCF("channels", "Channel initialization completed", map[string]interface{}{
 		"enabled_channels": len(m.channels),
 	})
 
@@ -226,11 +144,11 @@ func (m *Manager) StartAll(ctx context.Context) error {
 	go m.dispatchOutbound(dispatchCtx)
 
 	for name, channel := range m.channels {
-		logger.InfoCF("channels", "Starting channel", map[string]any{
+		logger.InfoCF("channels", "Starting channel", map[string]interface{}{
 			"channel": name,
 		})
 		if err := channel.Start(ctx); err != nil {
-			logger.ErrorCF("channels", "Failed to start channel", map[string]any{
+			logger.ErrorCF("channels", "Failed to start channel", map[string]interface{}{
 				"channel": name,
 				"error":   err.Error(),
 			})
@@ -253,11 +171,11 @@ func (m *Manager) StopAll(ctx context.Context) error {
 	}
 
 	for name, channel := range m.channels {
-		logger.InfoCF("channels", "Stopping channel", map[string]any{
+		logger.InfoCF("channels", "Stopping channel", map[string]interface{}{
 			"channel": name,
 		})
 		if err := channel.Stop(ctx); err != nil {
-			logger.ErrorCF("channels", "Error stopping channel", map[string]any{
+			logger.ErrorCF("channels", "Error stopping channel", map[string]interface{}{
 				"channel": name,
 				"error":   err.Error(),
 			})
@@ -292,14 +210,14 @@ func (m *Manager) dispatchOutbound(ctx context.Context) {
 			m.mu.RUnlock()
 
 			if !exists {
-				logger.WarnCF("channels", "Unknown channel for outbound message", map[string]any{
+				logger.WarnCF("channels", "Unknown channel for outbound message", map[string]interface{}{
 					"channel": msg.Channel,
 				})
 				continue
 			}
 
 			if err := channel.Send(ctx, msg); err != nil {
-				logger.ErrorCF("channels", "Error sending message to channel", map[string]any{
+				logger.ErrorCF("channels", "Error sending message to channel", map[string]interface{}{
 					"channel": msg.Channel,
 					"error":   err.Error(),
 				})
@@ -315,13 +233,13 @@ func (m *Manager) GetChannel(name string) (Channel, bool) {
 	return channel, ok
 }
 
-func (m *Manager) GetStatus() map[string]any {
+func (m *Manager) GetStatus() map[string]interface{} {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 
-	status := make(map[string]any)
+	status := make(map[string]interface{})
 	for name, channel := range m.channels {
-		status[name] = map[string]any{
+		status[name] = map[string]interface{}{
 			"enabled": true,
 			"running": channel.IsRunning(),
 		}

From 36eb68dd6784fe5b0815acd1d960e0980a3353f0 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Fri, 20 Feb 2026 23:25:44 +0800
Subject: [PATCH 29/52] refactor(channels): add channel subpackages and update
 gateway imports

---
 cmd/picoclaw/cmd_gateway.go                |   19 +-
 pkg/channels/dingtalk/dingtalk.go          |  202 ++++
 pkg/channels/dingtalk/init.go              |   13 +
 pkg/channels/discord/discord.go            |  373 +++++++
 pkg/channels/discord/init.go               |   13 +
 pkg/channels/feishu/common.go              |    9 +
 pkg/channels/feishu/feishu_32.go           |   37 +
 pkg/channels/feishu/feishu_64.go           |  221 ++++
 pkg/channels/feishu/init.go                |   13 +
 pkg/channels/line/init.go                  |   13 +
 pkg/channels/line/line.go                  |  607 +++++++++++
 pkg/channels/maixcam/init.go               |   13 +
 pkg/channels/maixcam/maixcam.go            |  244 +++++
 pkg/channels/onebot/init.go                |   13 +
 pkg/channels/onebot/onebot.go              |  980 ++++++++++++++++++
 pkg/channels/qq/init.go                    |   13 +
 pkg/channels/qq/qq.go                      |  248 +++++
 pkg/channels/slack/init.go                 |   13 +
 pkg/channels/slack/slack.go                |  444 ++++++++
 pkg/channels/slack/slack_test.go           |  174 ++++
 pkg/channels/telegram/init.go              |   13 +
 pkg/channels/telegram/telegram.go          |  526 ++++++++++
 pkg/channels/telegram/telegram_commands.go |  153 +++
 pkg/channels/wecom/app.go                  |  636 ++++++++++++
 pkg/channels/wecom/app_test.go             | 1086 ++++++++++++++++++++
 pkg/channels/wecom/bot.go                  |  469 +++++++++
 pkg/channels/wecom/bot_test.go             |  753 ++++++++++++++
 pkg/channels/wecom/common.go               |  134 +++
 pkg/channels/wecom/init.go                 |   16 +
 pkg/channels/whatsapp/init.go              |   13 +
 pkg/channels/whatsapp/whatsapp.go          |  193 ++++
 31 files changed, 7651 insertions(+), 3 deletions(-)
 create mode 100644 pkg/channels/dingtalk/dingtalk.go
 create mode 100644 pkg/channels/dingtalk/init.go
 create mode 100644 pkg/channels/discord/discord.go
 create mode 100644 pkg/channels/discord/init.go
 create mode 100644 pkg/channels/feishu/common.go
 create mode 100644 pkg/channels/feishu/feishu_32.go
 create mode 100644 pkg/channels/feishu/feishu_64.go
 create mode 100644 pkg/channels/feishu/init.go
 create mode 100644 pkg/channels/line/init.go
 create mode 100644 pkg/channels/line/line.go
 create mode 100644 pkg/channels/maixcam/init.go
 create mode 100644 pkg/channels/maixcam/maixcam.go
 create mode 100644 pkg/channels/onebot/init.go
 create mode 100644 pkg/channels/onebot/onebot.go
 create mode 100644 pkg/channels/qq/init.go
 create mode 100644 pkg/channels/qq/qq.go
 create mode 100644 pkg/channels/slack/init.go
 create mode 100644 pkg/channels/slack/slack.go
 create mode 100644 pkg/channels/slack/slack_test.go
 create mode 100644 pkg/channels/telegram/init.go
 create mode 100644 pkg/channels/telegram/telegram.go
 create mode 100644 pkg/channels/telegram/telegram_commands.go
 create mode 100644 pkg/channels/wecom/app.go
 create mode 100644 pkg/channels/wecom/app_test.go
 create mode 100644 pkg/channels/wecom/bot.go
 create mode 100644 pkg/channels/wecom/bot_test.go
 create mode 100644 pkg/channels/wecom/common.go
 create mode 100644 pkg/channels/wecom/init.go
 create mode 100644 pkg/channels/whatsapp/init.go
 create mode 100644 pkg/channels/whatsapp/whatsapp.go

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 28ef76ad3..29b31e071 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -16,6 +16,9 @@ import (
 	"github.com/sipeed/picoclaw/pkg/agent"
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
+	dch "github.com/sipeed/picoclaw/pkg/channels/discord"
+	slackch "github.com/sipeed/picoclaw/pkg/channels/slack"
+	tgram "github.com/sipeed/picoclaw/pkg/channels/telegram"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/cron"
 	"github.com/sipeed/picoclaw/pkg/devices"
@@ -26,6 +29,16 @@ import (
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
 	"github.com/sipeed/picoclaw/pkg/voice"
+
+	// Channel factory registrations (blank imports trigger init())
+	_ "github.com/sipeed/picoclaw/pkg/channels/dingtalk"
+	_ "github.com/sipeed/picoclaw/pkg/channels/feishu"
+	_ "github.com/sipeed/picoclaw/pkg/channels/line"
+	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
+	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
+	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
+	_ "github.com/sipeed/picoclaw/pkg/channels/wecom"
+	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp"
 )
 
 func gatewayCmd() {
@@ -138,19 +151,19 @@ func gatewayCmd() {
 
 	if transcriber != nil {
 		if telegramChannel, ok := channelManager.GetChannel("telegram"); ok {
-			if tc, ok := telegramChannel.(*channels.TelegramChannel); ok {
+			if tc, ok := telegramChannel.(*tgram.TelegramChannel); ok {
 				tc.SetTranscriber(transcriber)
 				logger.InfoC("voice", "Groq transcription attached to Telegram channel")
 			}
 		}
 		if discordChannel, ok := channelManager.GetChannel("discord"); ok {
-			if dc, ok := discordChannel.(*channels.DiscordChannel); ok {
+			if dc, ok := discordChannel.(*dch.DiscordChannel); ok {
 				dc.SetTranscriber(transcriber)
 				logger.InfoC("voice", "Groq transcription attached to Discord channel")
 			}
 		}
 		if slackChannel, ok := channelManager.GetChannel("slack"); ok {
-			if sc, ok := slackChannel.(*channels.SlackChannel); ok {
+			if sc, ok := slackChannel.(*slackch.SlackChannel); ok {
 				sc.SetTranscriber(transcriber)
 				logger.InfoC("voice", "Groq transcription attached to Slack channel")
 			}
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
new file mode 100644
index 000000000..0edb0023c
--- /dev/null
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -0,0 +1,202 @@
+// PicoClaw - Ultra-lightweight personal AI agent
+// DingTalk channel implementation using Stream Mode
+
+package dingtalk
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot"
+	"github.com/open-dingtalk/dingtalk-stream-sdk-go/client"
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+// DingTalkChannel implements the Channel interface for DingTalk (钉钉)
+// It uses WebSocket for receiving messages via stream mode and API for sending
+type DingTalkChannel struct {
+	*channels.BaseChannel
+	config       config.DingTalkConfig
+	clientID     string
+	clientSecret string
+	streamClient *client.StreamClient
+	ctx          context.Context
+	cancel       context.CancelFunc
+	// Map to store session webhooks for each chat
+	sessionWebhooks sync.Map // chatID -> sessionWebhook
+}
+
+// NewDingTalkChannel creates a new DingTalk channel instance
+func NewDingTalkChannel(cfg config.DingTalkConfig, messageBus *bus.MessageBus) (*DingTalkChannel, error) {
+	if cfg.ClientID == "" || cfg.ClientSecret == "" {
+		return nil, fmt.Errorf("dingtalk client_id and client_secret are required")
+	}
+
+	base := channels.NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom)
+
+	return &DingTalkChannel{
+		BaseChannel:  base,
+		config:       cfg,
+		clientID:     cfg.ClientID,
+		clientSecret: cfg.ClientSecret,
+	}, nil
+}
+
+// Start initializes the DingTalk channel with Stream Mode
+func (c *DingTalkChannel) Start(ctx context.Context) error {
+	logger.InfoC("dingtalk", "Starting DingTalk channel (Stream Mode)...")
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	// Create credential config
+	cred := client.NewAppCredentialConfig(c.clientID, c.clientSecret)
+
+	// Create the stream client with options
+	c.streamClient = client.NewStreamClient(
+		client.WithAppCredential(cred),
+		client.WithAutoReconnect(true),
+	)
+
+	// Register chatbot callback handler (IChatBotMessageHandler is a function type)
+	c.streamClient.RegisterChatBotCallbackRouter(c.onChatBotMessageReceived)
+
+	// Start the stream client
+	if err := c.streamClient.Start(c.ctx); err != nil {
+		return fmt.Errorf("failed to start stream client: %w", err)
+	}
+
+	c.SetRunning(true)
+	logger.InfoC("dingtalk", "DingTalk channel started (Stream Mode)")
+	return nil
+}
+
+// Stop gracefully stops the DingTalk channel
+func (c *DingTalkChannel) Stop(ctx context.Context) error {
+	logger.InfoC("dingtalk", "Stopping DingTalk channel...")
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	if c.streamClient != nil {
+		c.streamClient.Close()
+	}
+
+	c.SetRunning(false)
+	logger.InfoC("dingtalk", "DingTalk channel stopped")
+	return nil
+}
+
+// Send sends a message to DingTalk via the chatbot reply API
+func (c *DingTalkChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("dingtalk channel not running")
+	}
+
+	// Get session webhook from storage
+	sessionWebhookRaw, ok := c.sessionWebhooks.Load(msg.ChatID)
+	if !ok {
+		return fmt.Errorf("no session_webhook found for chat %s, cannot send message", msg.ChatID)
+	}
+
+	sessionWebhook, ok := sessionWebhookRaw.(string)
+	if !ok {
+		return fmt.Errorf("invalid session_webhook type for chat %s", msg.ChatID)
+	}
+
+	logger.DebugCF("dingtalk", "Sending message", map[string]interface{}{
+		"chat_id": msg.ChatID,
+		"preview": utils.Truncate(msg.Content, 100),
+	})
+
+	// Use the session webhook to send the reply
+	return c.SendDirectReply(ctx, sessionWebhook, msg.Content)
+}
+
+// onChatBotMessageReceived implements the IChatBotMessageHandler function signature
+// This is called by the Stream SDK when a new message arrives
+// IChatBotMessageHandler is: func(c context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error)
+func (c *DingTalkChannel) onChatBotMessageReceived(ctx context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error) {
+	// Extract message content from Text field
+	content := data.Text.Content
+	if content == "" {
+		// Try to extract from Content interface{} if Text is empty
+		if contentMap, ok := data.Content.(map[string]interface{}); ok {
+			if textContent, ok := contentMap["content"].(string); ok {
+				content = textContent
+			}
+		}
+	}
+
+	if content == "" {
+		return nil, nil // Ignore empty messages
+	}
+
+	senderID := data.SenderStaffId
+	senderNick := data.SenderNick
+	chatID := senderID
+	if data.ConversationType != "1" {
+		// For group chats
+		chatID = data.ConversationId
+	}
+
+	// Store the session webhook for this chat so we can reply later
+	c.sessionWebhooks.Store(chatID, data.SessionWebhook)
+
+	metadata := map[string]string{
+		"sender_name":       senderNick,
+		"conversation_id":   data.ConversationId,
+		"conversation_type": data.ConversationType,
+		"platform":          "dingtalk",
+		"session_webhook":   data.SessionWebhook,
+	}
+
+	if data.ConversationType == "1" {
+		metadata["peer_kind"] = "direct"
+		metadata["peer_id"] = senderID
+	} else {
+		metadata["peer_kind"] = "group"
+		metadata["peer_id"] = data.ConversationId
+	}
+
+	logger.DebugCF("dingtalk", "Received message", map[string]interface{}{
+		"sender_nick": senderNick,
+		"sender_id":   senderID,
+		"preview":     utils.Truncate(content, 50),
+	})
+
+	// Handle the message through the base channel
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+
+	// Return nil to indicate we've handled the message asynchronously
+	// The response will be sent through the message bus
+	return nil, nil
+}
+
+// SendDirectReply sends a direct reply using the session webhook
+func (c *DingTalkChannel) SendDirectReply(ctx context.Context, sessionWebhook, content string) error {
+	replier := chatbot.NewChatbotReplier()
+
+	// Convert string content to []byte for the API
+	contentBytes := []byte(content)
+	titleBytes := []byte("PicoClaw")
+
+	// Send markdown formatted reply
+	err := replier.SimpleReplyMarkdown(
+		ctx,
+		sessionWebhook,
+		titleBytes,
+		contentBytes,
+	)
+
+	if err != nil {
+		return fmt.Errorf("failed to send reply: %w", err)
+	}
+
+	return nil
+}
diff --git a/pkg/channels/dingtalk/init.go b/pkg/channels/dingtalk/init.go
new file mode 100644
index 000000000..5f49bce8c
--- /dev/null
+++ b/pkg/channels/dingtalk/init.go
@@ -0,0 +1,13 @@
+package dingtalk
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("dingtalk", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewDingTalkChannel(cfg.Channels.DingTalk, b)
+	})
+}
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
new file mode 100644
index 000000000..6c4efd87c
--- /dev/null
+++ b/pkg/channels/discord/discord.go
@@ -0,0 +1,373 @@
+package discord
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+	"github.com/sipeed/picoclaw/pkg/voice"
+)
+
+const (
+	transcriptionTimeout = 30 * time.Second
+	sendTimeout          = 10 * time.Second
+)
+
+type DiscordChannel struct {
+	*channels.BaseChannel
+	session     *discordgo.Session
+	config      config.DiscordConfig
+	transcriber *voice.GroqTranscriber
+	ctx         context.Context
+	typingMu    sync.Mutex
+	typingStop  map[string]chan struct{} // chatID → stop signal
+	botUserID   string                   // stored for mention checking
+}
+
+func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordChannel, error) {
+	session, err := discordgo.New("Bot " + cfg.Token)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create discord session: %w", err)
+	}
+
+	base := channels.NewBaseChannel("discord", cfg, bus, cfg.AllowFrom)
+
+	return &DiscordChannel{
+		BaseChannel: base,
+		session:     session,
+		config:      cfg,
+		transcriber: nil,
+		ctx:         context.Background(),
+		typingStop:  make(map[string]chan struct{}),
+	}, nil
+}
+
+func (c *DiscordChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
+	c.transcriber = transcriber
+}
+
+func (c *DiscordChannel) getContext() context.Context {
+	if c.ctx == nil {
+		return context.Background()
+	}
+	return c.ctx
+}
+
+func (c *DiscordChannel) Start(ctx context.Context) error {
+	logger.InfoC("discord", "Starting Discord bot")
+
+	c.ctx = ctx
+
+	// Get bot user ID before opening session to avoid race condition
+	botUser, err := c.session.User("@me")
+	if err != nil {
+		return fmt.Errorf("failed to get bot user: %w", err)
+	}
+	c.botUserID = botUser.ID
+
+	c.session.AddHandler(c.handleMessage)
+
+	if err := c.session.Open(); err != nil {
+		return fmt.Errorf("failed to open discord session: %w", err)
+	}
+
+	c.SetRunning(true)
+
+	logger.InfoCF("discord", "Discord bot connected", map[string]any{
+		"username": botUser.Username,
+		"user_id":  botUser.ID,
+	})
+
+	return nil
+}
+
+func (c *DiscordChannel) Stop(ctx context.Context) error {
+	logger.InfoC("discord", "Stopping Discord bot")
+	c.SetRunning(false)
+
+	// Stop all typing goroutines before closing session
+	c.typingMu.Lock()
+	for chatID, stop := range c.typingStop {
+		close(stop)
+		delete(c.typingStop, chatID)
+	}
+	c.typingMu.Unlock()
+
+	if err := c.session.Close(); err != nil {
+		return fmt.Errorf("failed to close discord session: %w", err)
+	}
+
+	return nil
+}
+
+func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	c.stopTyping(msg.ChatID)
+
+	if !c.IsRunning() {
+		return fmt.Errorf("discord bot not running")
+	}
+
+	channelID := msg.ChatID
+	if channelID == "" {
+		return fmt.Errorf("channel ID is empty")
+	}
+
+	runes := []rune(msg.Content)
+	if len(runes) == 0 {
+		return nil
+	}
+
+	chunks := utils.SplitMessage(msg.Content, 2000) // Split messages into chunks, Discord length limit: 2000 chars
+
+	for _, chunk := range chunks {
+		if err := c.sendChunk(ctx, channelID, chunk); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
+	// Use the passed ctx for timeout control
+	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
+	defer cancel()
+
+	done := make(chan error, 1)
+	go func() {
+		_, err := c.session.ChannelMessageSend(channelID, content)
+		done <- err
+	}()
+
+	select {
+	case err := <-done:
+		if err != nil {
+			return fmt.Errorf("failed to send discord message: %w", err)
+		}
+		return nil
+	case <-sendCtx.Done():
+		return fmt.Errorf("send message timeout: %w", sendCtx.Err())
+	}
+}
+
+// appendContent safely appends content to existing text
+func appendContent(content, suffix string) string {
+	if content == "" {
+		return suffix
+	}
+	return content + "\n" + suffix
+}
+
+func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.MessageCreate) {
+	if m == nil || m.Author == nil {
+		return
+	}
+
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	// Check allowlist first to avoid downloading attachments and transcribing for rejected users
+	if !c.IsAllowed(m.Author.ID) {
+		logger.DebugCF("discord", "Message rejected by allowlist", map[string]any{
+			"user_id": m.Author.ID,
+		})
+		return
+	}
+
+	// If configured to only respond to mentions, check if bot is mentioned
+	// Skip this check for DMs (GuildID is empty) - DMs should always be responded to
+	if c.config.MentionOnly && m.GuildID != "" {
+		isMentioned := false
+		for _, mention := range m.Mentions {
+			if mention.ID == c.botUserID {
+				isMentioned = true
+				break
+			}
+		}
+		if !isMentioned {
+			logger.DebugCF("discord", "Message ignored - bot not mentioned", map[string]any{
+				"user_id": m.Author.ID,
+			})
+			return
+		}
+	}
+
+	senderID := m.Author.ID
+	senderName := m.Author.Username
+	if m.Author.Discriminator != "" && m.Author.Discriminator != "0" {
+		senderName += "#" + m.Author.Discriminator
+	}
+
+	content := m.Content
+	content = c.stripBotMention(content)
+	mediaPaths := make([]string, 0, len(m.Attachments))
+	localFiles := make([]string, 0, len(m.Attachments))
+
+	// Ensure temp files are cleaned up when function returns
+	defer func() {
+		for _, file := range localFiles {
+			if err := os.Remove(file); err != nil {
+				logger.DebugCF("discord", "Failed to cleanup temp file", map[string]any{
+					"file":  file,
+					"error": err.Error(),
+				})
+			}
+		}
+	}()
+
+	for _, attachment := range m.Attachments {
+		isAudio := utils.IsAudioFile(attachment.Filename, attachment.ContentType)
+
+		if isAudio {
+			localPath := c.downloadAttachment(attachment.URL, attachment.Filename)
+			if localPath != "" {
+				localFiles = append(localFiles, localPath)
+
+				transcribedText := ""
+				if c.transcriber != nil && c.transcriber.IsAvailable() {
+					ctx, cancel := context.WithTimeout(c.getContext(), transcriptionTimeout)
+					result, err := c.transcriber.Transcribe(ctx, localPath)
+					cancel() // Release context resources immediately to avoid leaks in for loop
+
+					if err != nil {
+						logger.ErrorCF("discord", "Voice transcription failed", map[string]any{
+							"error": err.Error(),
+						})
+						transcribedText = fmt.Sprintf("[audio: %s (transcription failed)]", attachment.Filename)
+					} else {
+						transcribedText = fmt.Sprintf("[audio transcription: %s]", result.Text)
+						logger.DebugCF("discord", "Audio transcribed successfully", map[string]any{
+							"text": result.Text,
+						})
+					}
+				} else {
+					transcribedText = fmt.Sprintf("[audio: %s]", attachment.Filename)
+				}
+
+				content = appendContent(content, transcribedText)
+			} 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))
+			}
+		} else {
+			mediaPaths = append(mediaPaths, attachment.URL)
+			content = appendContent(content, fmt.Sprintf("[attachment: %s]", attachment.URL))
+		}
+	}
+
+	if content == "" && len(mediaPaths) == 0 {
+		return
+	}
+
+	if content == "" {
+		content = "[media only]"
+	}
+
+	// Start typing after all early returns — guaranteed to have a matching Send()
+	c.startTyping(m.ChannelID)
+
+	logger.DebugCF("discord", "Received message", map[string]any{
+		"sender_name": senderName,
+		"sender_id":   senderID,
+		"preview":     utils.Truncate(content, 50),
+	})
+
+	peerKind := "channel"
+	peerID := m.ChannelID
+	if m.GuildID == "" {
+		peerKind = "direct"
+		peerID = senderID
+	}
+
+	metadata := map[string]string{
+		"message_id":   m.ID,
+		"user_id":      senderID,
+		"username":     m.Author.Username,
+		"display_name": senderName,
+		"guild_id":     m.GuildID,
+		"channel_id":   m.ChannelID,
+		"is_dm":        fmt.Sprintf("%t", m.GuildID == ""),
+		"peer_kind":    peerKind,
+		"peer_id":      peerID,
+	}
+
+	c.HandleMessage(senderID, m.ChannelID, content, mediaPaths, metadata)
+}
+
+// startTyping starts a continuous typing indicator loop for the given chatID.
+// It stops any existing typing loop for that chatID before starting a new one.
+func (c *DiscordChannel) startTyping(chatID string) {
+	c.typingMu.Lock()
+	// Stop existing loop for this chatID if any
+	if stop, ok := c.typingStop[chatID]; ok {
+		close(stop)
+	}
+	stop := make(chan struct{})
+	c.typingStop[chatID] = stop
+	c.typingMu.Unlock()
+
+	go func() {
+		if err := c.session.ChannelTyping(chatID); err != nil {
+			logger.DebugCF("discord", "ChannelTyping error", map[string]interface{}{"chatID": chatID, "err": err})
+		}
+		ticker := time.NewTicker(8 * time.Second)
+		defer ticker.Stop()
+		timeout := time.After(5 * time.Minute)
+		for {
+			select {
+			case <-stop:
+				return
+			case <-timeout:
+				return
+			case <-c.ctx.Done():
+				return
+			case <-ticker.C:
+				if err := c.session.ChannelTyping(chatID); err != nil {
+					logger.DebugCF("discord", "ChannelTyping error", map[string]interface{}{"chatID": chatID, "err": err})
+				}
+			}
+		}
+	}()
+}
+
+// stopTyping stops the typing indicator loop for the given chatID.
+func (c *DiscordChannel) stopTyping(chatID string) {
+	c.typingMu.Lock()
+	defer c.typingMu.Unlock()
+	if stop, ok := c.typingStop[chatID]; ok {
+		close(stop)
+		delete(c.typingStop, chatID)
+	}
+}
+
+func (c *DiscordChannel) downloadAttachment(url, filename string) string {
+	return utils.DownloadFile(url, filename, utils.DownloadOptions{
+		LoggerPrefix: "discord",
+	})
+}
+
+// stripBotMention removes the bot mention from the message content.
+// Discord mentions have the format <@USER_ID> or <@!USER_ID> (with nickname).
+func (c *DiscordChannel) stripBotMention(text string) string {
+	if c.botUserID == "" {
+		return text
+	}
+	// Remove both regular mention <@USER_ID> and nickname mention <@!USER_ID>
+	text = strings.ReplaceAll(text, fmt.Sprintf("<@%s>", c.botUserID), "")
+	text = strings.ReplaceAll(text, fmt.Sprintf("<@!%s>", c.botUserID), "")
+	return strings.TrimSpace(text)
+}
diff --git a/pkg/channels/discord/init.go b/pkg/channels/discord/init.go
new file mode 100644
index 000000000..15a539804
--- /dev/null
+++ b/pkg/channels/discord/init.go
@@ -0,0 +1,13 @@
+package discord
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("discord", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewDiscordChannel(cfg.Channels.Discord, b)
+	})
+}
diff --git a/pkg/channels/feishu/common.go b/pkg/channels/feishu/common.go
new file mode 100644
index 000000000..e8a057741
--- /dev/null
+++ b/pkg/channels/feishu/common.go
@@ -0,0 +1,9 @@
+package feishu
+
+// stringValue safely dereferences a *string pointer.
+func stringValue(v *string) string {
+	if v == nil {
+		return ""
+	}
+	return *v
+}
diff --git a/pkg/channels/feishu/feishu_32.go b/pkg/channels/feishu/feishu_32.go
new file mode 100644
index 000000000..14711e49e
--- /dev/null
+++ b/pkg/channels/feishu/feishu_32.go
@@ -0,0 +1,37 @@
+//go:build !amd64 && !arm64 && !riscv64 && !mips64 && !ppc64
+
+package feishu
+
+import (
+	"context"
+	"errors"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+// FeishuChannel is a stub implementation for 32-bit architectures
+type FeishuChannel struct {
+	*channels.BaseChannel
+}
+
+// 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 nil
+}
+
+// Stop is a stub method to satisfy the Channel interface
+func (c *FeishuChannel) Stop(ctx context.Context) error {
+	return nil
+}
+
+// Send is a stub method to satisfy the Channel interface
+func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	return errors.New("feishu channel is not supported on 32-bit architectures")
+}
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
new file mode 100644
index 000000000..a49ee34cb
--- /dev/null
+++ b/pkg/channels/feishu/feishu_64.go
@@ -0,0 +1,221 @@
+//go:build amd64 || arm64 || riscv64 || mips64 || ppc64
+
+package feishu
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"time"
+
+	lark "github.com/larksuite/oapi-sdk-go/v3"
+	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"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+type FeishuChannel struct {
+	*channels.BaseChannel
+	config   config.FeishuConfig
+	client   *lark.Client
+	wsClient *larkws.Client
+
+	mu     sync.Mutex
+	cancel context.CancelFunc
+}
+
+func NewFeishuChannel(cfg config.FeishuConfig, bus *bus.MessageBus) (*FeishuChannel, error) {
+	base := channels.NewBaseChannel("feishu", cfg, bus, cfg.AllowFrom)
+
+	return &FeishuChannel{
+		BaseChannel: base,
+		config:      cfg,
+		client:      lark.NewClient(cfg.AppID, cfg.AppSecret),
+	}, 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")
+	}
+
+	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]interface{}{
+				"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
+}
+
+func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("feishu channel not running")
+	}
+
+	if msg.ChatID == "" {
+		return fmt.Errorf("chat ID is empty")
+	}
+
+	payload, err := json.Marshal(map[string]string{"text": msg.Content})
+	if err != nil {
+		return fmt.Errorf("failed to marshal feishu content: %w", err)
+	}
+
+	req := larkim.NewCreateMessageReqBuilder().
+		ReceiveIdType(larkim.ReceiveIdTypeChatId).
+		Body(larkim.NewCreateMessageReqBodyBuilder().
+			ReceiveId(msg.ChatID).
+			MsgType(larkim.MsgTypeText).
+			Content(string(payload)).
+			Uuid(fmt.Sprintf("picoclaw-%d", time.Now().UnixNano())).
+			Build()).
+		Build()
+
+	resp, err := c.client.Im.V1.Message.Create(ctx, req)
+	if err != nil {
+		return fmt.Errorf("failed to send feishu message: %w", err)
+	}
+
+	if !resp.Success() {
+		return fmt.Errorf("feishu api error: code=%d msg=%s", resp.Code, resp.Msg)
+	}
+
+	logger.DebugCF("feishu", "Feishu message sent", map[string]interface{}{
+		"chat_id": msg.ChatID,
+	})
+
+	return nil
+}
+
+func (c *FeishuChannel) handleMessageReceive(_ 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"
+	}
+
+	content := extractFeishuMessageContent(message)
+	if content == "" {
+		content = "[empty message]"
+	}
+
+	metadata := map[string]string{}
+	if messageID := stringValue(message.MessageId); messageID != "" {
+		metadata["message_id"] = messageID
+	}
+	if messageType := stringValue(message.MessageType); messageType != "" {
+		metadata["message_type"] = messageType
+	}
+	if chatType := stringValue(message.ChatType); chatType != "" {
+		metadata["chat_type"] = chatType
+	}
+	if sender != nil && sender.TenantKey != nil {
+		metadata["tenant_key"] = *sender.TenantKey
+	}
+
+	chatType := stringValue(message.ChatType)
+	if chatType == "p2p" {
+		metadata["peer_kind"] = "direct"
+		metadata["peer_id"] = senderID
+	} else {
+		metadata["peer_kind"] = "group"
+		metadata["peer_id"] = chatID
+	}
+
+	logger.InfoCF("feishu", "Feishu message received", map[string]interface{}{
+		"sender_id": senderID,
+		"chat_id":   chatID,
+		"preview":   utils.Truncate(content, 80),
+	})
+
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	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 ""
+}
+
+func extractFeishuMessageContent(message *larkim.EventMessage) string {
+	if message == nil || message.Content == nil || *message.Content == "" {
+		return ""
+	}
+
+	if message.MessageType != nil && *message.MessageType == larkim.MsgTypeText {
+		var textPayload struct {
+			Text string `json:"text"`
+		}
+		if err := json.Unmarshal([]byte(*message.Content), &textPayload); err == nil {
+			return textPayload.Text
+		}
+	}
+
+	return *message.Content
+}
diff --git a/pkg/channels/feishu/init.go b/pkg/channels/feishu/init.go
new file mode 100644
index 000000000..7e5a62dae
--- /dev/null
+++ b/pkg/channels/feishu/init.go
@@ -0,0 +1,13 @@
+package feishu
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("feishu", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewFeishuChannel(cfg.Channels.Feishu, b)
+	})
+}
diff --git a/pkg/channels/line/init.go b/pkg/channels/line/init.go
new file mode 100644
index 000000000..9265575cc
--- /dev/null
+++ b/pkg/channels/line/init.go
@@ -0,0 +1,13 @@
+package line
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("line", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewLINEChannel(cfg.Channels.LINE, b)
+	})
+}
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
new file mode 100644
index 000000000..7df0491d9
--- /dev/null
+++ b/pkg/channels/line/line.go
@@ -0,0 +1,607 @@
+package line
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+const (
+	lineAPIBase          = "https://api.line.me/v2/bot"
+	lineDataAPIBase      = "https://api-data.line.me/v2/bot"
+	lineReplyEndpoint    = lineAPIBase + "/message/reply"
+	linePushEndpoint     = lineAPIBase + "/message/push"
+	lineContentEndpoint  = lineDataAPIBase + "/message/%s/content"
+	lineBotInfoEndpoint  = lineAPIBase + "/info"
+	lineLoadingEndpoint  = lineAPIBase + "/chat/loading/start"
+	lineReplyTokenMaxAge = 25 * time.Second
+)
+
+type replyTokenEntry struct {
+	token     string
+	timestamp time.Time
+}
+
+// LINEChannel implements the Channel interface for LINE Official Account
+// using the LINE Messaging API with HTTP webhook for receiving messages
+// and REST API for sending messages.
+type LINEChannel struct {
+	*channels.BaseChannel
+	config         config.LINEConfig
+	httpServer     *http.Server
+	botUserID      string   // Bot's user ID
+	botBasicID     string   // Bot's basic ID (e.g. @216ru...)
+	botDisplayName string   // Bot's display name for text-based mention detection
+	replyTokens    sync.Map // chatID -> replyTokenEntry
+	quoteTokens    sync.Map // chatID -> quoteToken (string)
+	ctx            context.Context
+	cancel         context.CancelFunc
+}
+
+// NewLINEChannel creates a new LINE channel instance.
+func NewLINEChannel(cfg config.LINEConfig, messageBus *bus.MessageBus) (*LINEChannel, error) {
+	if cfg.ChannelSecret == "" || cfg.ChannelAccessToken == "" {
+		return nil, fmt.Errorf("line channel_secret and channel_access_token are required")
+	}
+
+	base := channels.NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom)
+
+	return &LINEChannel{
+		BaseChannel: base,
+		config:      cfg,
+	}, nil
+}
+
+// Start launches the HTTP webhook server.
+func (c *LINEChannel) Start(ctx context.Context) error {
+	logger.InfoC("line", "Starting LINE channel (Webhook Mode)")
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	// Fetch bot profile to get bot's userId for mention detection
+	if err := c.fetchBotInfo(); err != nil {
+		logger.WarnCF("line", "Failed to fetch bot info (mention detection disabled)", map[string]interface{}{
+			"error": err.Error(),
+		})
+	} else {
+		logger.InfoCF("line", "Bot info fetched", map[string]interface{}{
+			"bot_user_id":  c.botUserID,
+			"basic_id":     c.botBasicID,
+			"display_name": c.botDisplayName,
+		})
+	}
+
+	mux := http.NewServeMux()
+	path := c.config.WebhookPath
+	if path == "" {
+		path = "/webhook/line"
+	}
+	mux.HandleFunc(path, c.webhookHandler)
+
+	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
+	c.httpServer = &http.Server{
+		Addr:    addr,
+		Handler: mux,
+	}
+
+	go func() {
+		logger.InfoCF("line", "LINE webhook server listening", map[string]interface{}{
+			"addr": addr,
+			"path": path,
+		})
+		if err := c.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.ErrorCF("line", "Webhook server error", map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+	}()
+
+	c.SetRunning(true)
+	logger.InfoC("line", "LINE channel started (Webhook Mode)")
+	return nil
+}
+
+// fetchBotInfo retrieves the bot's userId, basicId, and displayName from the LINE API.
+func (c *LINEChannel) fetchBotInfo() error {
+	req, err := http.NewRequest(http.MethodGet, lineBotInfoEndpoint, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", "Bearer "+c.config.ChannelAccessToken)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("bot info API returned status %d", resp.StatusCode)
+	}
+
+	var info struct {
+		UserID      string `json:"userId"`
+		BasicID     string `json:"basicId"`
+		DisplayName string `json:"displayName"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
+		return err
+	}
+
+	c.botUserID = info.UserID
+	c.botBasicID = info.BasicID
+	c.botDisplayName = info.DisplayName
+	return nil
+}
+
+// Stop gracefully shuts down the HTTP server.
+func (c *LINEChannel) Stop(ctx context.Context) error {
+	logger.InfoC("line", "Stopping LINE channel")
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	if c.httpServer != nil {
+		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+		if err := c.httpServer.Shutdown(shutdownCtx); err != nil {
+			logger.ErrorCF("line", "Webhook server shutdown error", map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+	}
+
+	c.SetRunning(false)
+	logger.InfoC("line", "LINE channel stopped")
+	return nil
+}
+
+// webhookHandler handles incoming LINE webhook requests.
+func (c *LINEChannel) webhookHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		logger.ErrorCF("line", "Failed to read request body", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Bad request", http.StatusBadRequest)
+		return
+	}
+
+	signature := r.Header.Get("X-Line-Signature")
+	if !c.verifySignature(body, signature) {
+		logger.WarnC("line", "Invalid webhook signature")
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	var payload struct {
+		Events []lineEvent `json:"events"`
+	}
+	if err := json.Unmarshal(body, &payload); err != nil {
+		logger.ErrorCF("line", "Failed to parse webhook payload", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Bad request", http.StatusBadRequest)
+		return
+	}
+
+	// Return 200 immediately, process events asynchronously
+	w.WriteHeader(http.StatusOK)
+
+	for _, event := range payload.Events {
+		go c.processEvent(event)
+	}
+}
+
+// verifySignature validates the X-Line-Signature using HMAC-SHA256.
+func (c *LINEChannel) verifySignature(body []byte, signature string) bool {
+	if signature == "" {
+		return false
+	}
+
+	mac := hmac.New(sha256.New, []byte(c.config.ChannelSecret))
+	mac.Write(body)
+	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
+
+	return hmac.Equal([]byte(expected), []byte(signature))
+}
+
+// LINE webhook event types
+type lineEvent struct {
+	Type       string          `json:"type"`
+	ReplyToken string          `json:"replyToken"`
+	Source     lineSource      `json:"source"`
+	Message    json.RawMessage `json:"message"`
+	Timestamp  int64           `json:"timestamp"`
+}
+
+type lineSource struct {
+	Type    string `json:"type"` // "user", "group", "room"
+	UserID  string `json:"userId"`
+	GroupID string `json:"groupId"`
+	RoomID  string `json:"roomId"`
+}
+
+type lineMessage struct {
+	ID         string `json:"id"`
+	Type       string `json:"type"` // "text", "image", "video", "audio", "file", "sticker"
+	Text       string `json:"text"`
+	QuoteToken string `json:"quoteToken"`
+	Mention    *struct {
+		Mentionees []lineMentionee `json:"mentionees"`
+	} `json:"mention"`
+	ContentProvider struct {
+		Type string `json:"type"`
+	} `json:"contentProvider"`
+}
+
+type lineMentionee struct {
+	Index  int    `json:"index"`
+	Length int    `json:"length"`
+	Type   string `json:"type"` // "user", "all"
+	UserID string `json:"userId"`
+}
+
+func (c *LINEChannel) processEvent(event lineEvent) {
+	if event.Type != "message" {
+		logger.DebugCF("line", "Ignoring non-message event", map[string]interface{}{
+			"type": event.Type,
+		})
+		return
+	}
+
+	senderID := event.Source.UserID
+	chatID := c.resolveChatID(event.Source)
+	isGroup := event.Source.Type == "group" || event.Source.Type == "room"
+
+	var msg lineMessage
+	if err := json.Unmarshal(event.Message, &msg); err != nil {
+		logger.ErrorCF("line", "Failed to parse message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	// In group chats, only respond when the bot is mentioned
+	if isGroup && !c.isBotMentioned(msg) {
+		logger.DebugCF("line", "Ignoring group message without mention", map[string]interface{}{
+			"chat_id": chatID,
+		})
+		return
+	}
+
+	// Store reply token for later use
+	if event.ReplyToken != "" {
+		c.replyTokens.Store(chatID, replyTokenEntry{
+			token:     event.ReplyToken,
+			timestamp: time.Now(),
+		})
+	}
+
+	// Store quote token for quoting the original message in reply
+	if msg.QuoteToken != "" {
+		c.quoteTokens.Store(chatID, msg.QuoteToken)
+	}
+
+	var content string
+	var mediaPaths []string
+	localFiles := []string{}
+
+	defer func() {
+		for _, file := range localFiles {
+			if err := os.Remove(file); err != nil {
+				logger.DebugCF("line", "Failed to cleanup temp file", map[string]interface{}{
+					"file":  file,
+					"error": err.Error(),
+				})
+			}
+		}
+	}()
+
+	switch msg.Type {
+	case "text":
+		content = msg.Text
+		// Strip bot mention from text in group chats
+		if isGroup {
+			content = c.stripBotMention(content, msg)
+		}
+	case "image":
+		localPath := c.downloadContent(msg.ID, "image.jpg")
+		if localPath != "" {
+			localFiles = append(localFiles, localPath)
+			mediaPaths = append(mediaPaths, localPath)
+			content = "[image]"
+		}
+	case "audio":
+		localPath := c.downloadContent(msg.ID, "audio.m4a")
+		if localPath != "" {
+			localFiles = append(localFiles, localPath)
+			mediaPaths = append(mediaPaths, localPath)
+			content = "[audio]"
+		}
+	case "video":
+		localPath := c.downloadContent(msg.ID, "video.mp4")
+		if localPath != "" {
+			localFiles = append(localFiles, localPath)
+			mediaPaths = append(mediaPaths, localPath)
+			content = "[video]"
+		}
+	case "file":
+		content = "[file]"
+	case "sticker":
+		content = "[sticker]"
+	default:
+		content = fmt.Sprintf("[%s]", msg.Type)
+	}
+
+	if strings.TrimSpace(content) == "" {
+		return
+	}
+
+	metadata := map[string]string{
+		"platform":    "line",
+		"source_type": event.Source.Type,
+		"message_id":  msg.ID,
+	}
+
+	if isGroup {
+		metadata["peer_kind"] = "group"
+		metadata["peer_id"] = chatID
+	} else {
+		metadata["peer_kind"] = "direct"
+		metadata["peer_id"] = senderID
+	}
+
+	logger.DebugCF("line", "Received message", map[string]interface{}{
+		"sender_id":    senderID,
+		"chat_id":      chatID,
+		"message_type": msg.Type,
+		"is_group":     isGroup,
+		"preview":      utils.Truncate(content, 50),
+	})
+
+	// Show typing/loading indicator (requires user ID, not group ID)
+	c.sendLoading(senderID)
+
+	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+}
+
+// isBotMentioned checks if the bot is mentioned in the message.
+// It first checks the mention metadata (userId match), then falls back
+// to text-based detection using the bot's display name, since LINE may
+// not include userId in mentionees for Official Accounts.
+func (c *LINEChannel) isBotMentioned(msg lineMessage) bool {
+	// Check mention metadata
+	if msg.Mention != nil {
+		for _, m := range msg.Mention.Mentionees {
+			if m.Type == "all" {
+				return true
+			}
+			if c.botUserID != "" && m.UserID == c.botUserID {
+				return true
+			}
+		}
+		// Mention metadata exists with mentionees but bot not matched by userId.
+		// The bot IS likely mentioned (LINE includes mention struct when bot is @-ed),
+		// so check if any mentionee overlaps with bot display name in text.
+		if c.botDisplayName != "" {
+			for _, m := range msg.Mention.Mentionees {
+				if m.Index >= 0 && m.Length > 0 {
+					runes := []rune(msg.Text)
+					end := m.Index + m.Length
+					if end <= len(runes) {
+						mentionText := string(runes[m.Index:end])
+						if strings.Contains(mentionText, c.botDisplayName) {
+							return true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Fallback: text-based detection with display name
+	if c.botDisplayName != "" && strings.Contains(msg.Text, "@"+c.botDisplayName) {
+		return true
+	}
+
+	return false
+}
+
+// stripBotMention removes the @BotName mention text from the message.
+func (c *LINEChannel) stripBotMention(text string, msg lineMessage) string {
+	stripped := false
+
+	// Try to strip using mention metadata indices
+	if msg.Mention != nil {
+		runes := []rune(text)
+		for i := len(msg.Mention.Mentionees) - 1; i >= 0; i-- {
+			m := msg.Mention.Mentionees[i]
+			// Strip if userId matches OR if the mention text contains the bot display name
+			shouldStrip := false
+			if c.botUserID != "" && m.UserID == c.botUserID {
+				shouldStrip = true
+			} else if c.botDisplayName != "" && m.Index >= 0 && m.Length > 0 {
+				end := m.Index + m.Length
+				if end <= len(runes) {
+					mentionText := string(runes[m.Index:end])
+					if strings.Contains(mentionText, c.botDisplayName) {
+						shouldStrip = true
+					}
+				}
+			}
+			if shouldStrip {
+				start := m.Index
+				end := m.Index + m.Length
+				if start >= 0 && end <= len(runes) {
+					runes = append(runes[:start], runes[end:]...)
+					stripped = true
+				}
+			}
+		}
+		if stripped {
+			return strings.TrimSpace(string(runes))
+		}
+	}
+
+	// Fallback: strip @DisplayName from text
+	if c.botDisplayName != "" {
+		text = strings.ReplaceAll(text, "@"+c.botDisplayName, "")
+	}
+
+	return strings.TrimSpace(text)
+}
+
+// resolveChatID determines the chat ID from the event source.
+// For group/room messages, use the group/room ID; for 1:1, use the user ID.
+func (c *LINEChannel) resolveChatID(source lineSource) string {
+	switch source.Type {
+	case "group":
+		return source.GroupID
+	case "room":
+		return source.RoomID
+	default:
+		return source.UserID
+	}
+}
+
+// Send sends a message to LINE. It first tries the Reply API (free)
+// using a cached reply token, then falls back to the Push API.
+func (c *LINEChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("line channel not running")
+	}
+
+	// Load and consume quote token for this chat
+	var quoteToken string
+	if qt, ok := c.quoteTokens.LoadAndDelete(msg.ChatID); ok {
+		quoteToken = qt.(string)
+	}
+
+	// Try reply token first (free, valid for ~25 seconds)
+	if entry, ok := c.replyTokens.LoadAndDelete(msg.ChatID); ok {
+		tokenEntry := entry.(replyTokenEntry)
+		if time.Since(tokenEntry.timestamp) < lineReplyTokenMaxAge {
+			if err := c.sendReply(ctx, tokenEntry.token, msg.Content, quoteToken); err == nil {
+				logger.DebugCF("line", "Message sent via Reply API", map[string]interface{}{
+					"chat_id": msg.ChatID,
+					"quoted":  quoteToken != "",
+				})
+				return nil
+			}
+			logger.DebugC("line", "Reply API failed, falling back to Push API")
+		}
+	}
+
+	// Fall back to Push API
+	return c.sendPush(ctx, msg.ChatID, msg.Content, quoteToken)
+}
+
+// buildTextMessage creates a text message object, optionally with quoteToken.
+func buildTextMessage(content, quoteToken string) map[string]string {
+	msg := map[string]string{
+		"type": "text",
+		"text": content,
+	}
+	if quoteToken != "" {
+		msg["quoteToken"] = quoteToken
+	}
+	return msg
+}
+
+// sendReply sends a message using the LINE Reply API.
+func (c *LINEChannel) sendReply(ctx context.Context, replyToken, content, quoteToken string) error {
+	payload := map[string]interface{}{
+		"replyToken": replyToken,
+		"messages":   []map[string]string{buildTextMessage(content, quoteToken)},
+	}
+
+	return c.callAPI(ctx, lineReplyEndpoint, payload)
+}
+
+// sendPush sends a message using the LINE Push API.
+func (c *LINEChannel) sendPush(ctx context.Context, to, content, quoteToken string) error {
+	payload := map[string]interface{}{
+		"to":       to,
+		"messages": []map[string]string{buildTextMessage(content, quoteToken)},
+	}
+
+	return c.callAPI(ctx, linePushEndpoint, payload)
+}
+
+// sendLoading sends a loading animation indicator to the chat.
+func (c *LINEChannel) sendLoading(chatID string) {
+	payload := map[string]interface{}{
+		"chatId":         chatID,
+		"loadingSeconds": 60,
+	}
+	if err := c.callAPI(c.ctx, lineLoadingEndpoint, payload); err != nil {
+		logger.DebugCF("line", "Failed to send loading indicator", map[string]interface{}{
+			"error": err.Error(),
+		})
+	}
+}
+
+// callAPI makes an authenticated POST request to the LINE API.
+func (c *LINEChannel) callAPI(ctx context.Context, endpoint string, payload interface{}) error {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("failed to marshal payload: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+c.config.ChannelAccessToken)
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("API request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("LINE API error (status %d): %s", resp.StatusCode, string(respBody))
+	}
+
+	return nil
+}
+
+// downloadContent downloads media content from the LINE API.
+func (c *LINEChannel) downloadContent(messageID, filename string) string {
+	url := fmt.Sprintf(lineContentEndpoint, messageID)
+	return utils.DownloadFile(url, filename, utils.DownloadOptions{
+		LoggerPrefix: "line",
+		ExtraHeaders: map[string]string{
+			"Authorization": "Bearer " + c.config.ChannelAccessToken,
+		},
+	})
+}
diff --git a/pkg/channels/maixcam/init.go b/pkg/channels/maixcam/init.go
new file mode 100644
index 000000000..5a269b22b
--- /dev/null
+++ b/pkg/channels/maixcam/init.go
@@ -0,0 +1,13 @@
+package maixcam
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("maixcam", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewMaixCamChannel(cfg.Channels.MaixCam, b)
+	})
+}
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
new file mode 100644
index 000000000..d3c6662d7
--- /dev/null
+++ b/pkg/channels/maixcam/maixcam.go
@@ -0,0 +1,244 @@
+package maixcam
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"sync"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+)
+
+type MaixCamChannel struct {
+	*channels.BaseChannel
+	config     config.MaixCamConfig
+	listener   net.Listener
+	clients    map[net.Conn]bool
+	clientsMux sync.RWMutex
+}
+
+type MaixCamMessage struct {
+	Type      string                 `json:"type"`
+	Tips      string                 `json:"tips"`
+	Timestamp float64                `json:"timestamp"`
+	Data      map[string]interface{} `json:"data"`
+}
+
+func NewMaixCamChannel(cfg config.MaixCamConfig, bus *bus.MessageBus) (*MaixCamChannel, error) {
+	base := channels.NewBaseChannel("maixcam", cfg, bus, cfg.AllowFrom)
+
+	return &MaixCamChannel{
+		BaseChannel: base,
+		config:      cfg,
+		clients:     make(map[net.Conn]bool),
+	}, nil
+}
+
+func (c *MaixCamChannel) Start(ctx context.Context) error {
+	logger.InfoC("maixcam", "Starting MaixCam channel server")
+
+	addr := fmt.Sprintf("%s:%d", c.config.Host, c.config.Port)
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return fmt.Errorf("failed to listen on %s: %w", addr, err)
+	}
+
+	c.listener = listener
+	c.SetRunning(true)
+
+	logger.InfoCF("maixcam", "MaixCam server listening", map[string]interface{}{
+		"host": c.config.Host,
+		"port": c.config.Port,
+	})
+
+	go c.acceptConnections(ctx)
+
+	return nil
+}
+
+func (c *MaixCamChannel) acceptConnections(ctx context.Context) {
+	logger.DebugC("maixcam", "Starting connection acceptor")
+
+	for {
+		select {
+		case <-ctx.Done():
+			logger.InfoC("maixcam", "Stopping connection acceptor")
+			return
+		default:
+			conn, err := c.listener.Accept()
+			if err != nil {
+				if c.IsRunning() {
+					logger.ErrorCF("maixcam", "Failed to accept connection", map[string]interface{}{
+						"error": err.Error(),
+					})
+				}
+				return
+			}
+
+			logger.InfoCF("maixcam", "New connection from MaixCam device", map[string]interface{}{
+				"remote_addr": conn.RemoteAddr().String(),
+			})
+
+			c.clientsMux.Lock()
+			c.clients[conn] = true
+			c.clientsMux.Unlock()
+
+			go c.handleConnection(conn, ctx)
+		}
+	}
+}
+
+func (c *MaixCamChannel) handleConnection(conn net.Conn, ctx context.Context) {
+	logger.DebugC("maixcam", "Handling MaixCam connection")
+
+	defer func() {
+		conn.Close()
+		c.clientsMux.Lock()
+		delete(c.clients, conn)
+		c.clientsMux.Unlock()
+		logger.DebugC("maixcam", "Connection closed")
+	}()
+
+	decoder := json.NewDecoder(conn)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			var msg MaixCamMessage
+			if err := decoder.Decode(&msg); err != nil {
+				if err.Error() != "EOF" {
+					logger.ErrorCF("maixcam", "Failed to decode message", map[string]interface{}{
+						"error": err.Error(),
+					})
+				}
+				return
+			}
+
+			c.processMessage(msg, conn)
+		}
+	}
+}
+
+func (c *MaixCamChannel) processMessage(msg MaixCamMessage, conn net.Conn) {
+	switch msg.Type {
+	case "person_detected":
+		c.handlePersonDetection(msg)
+	case "heartbeat":
+		logger.DebugC("maixcam", "Received heartbeat")
+	case "status":
+		c.handleStatusUpdate(msg)
+	default:
+		logger.WarnCF("maixcam", "Unknown message type", map[string]interface{}{
+			"type": msg.Type,
+		})
+	}
+}
+
+func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
+	logger.InfoCF("maixcam", "", map[string]interface{}{
+		"timestamp": msg.Timestamp,
+		"data":      msg.Data,
+	})
+
+	senderID := "maixcam"
+	chatID := "default"
+
+	classInfo, ok := msg.Data["class_name"].(string)
+	if !ok {
+		classInfo = "person"
+	}
+
+	score, _ := msg.Data["score"].(float64)
+	x, _ := msg.Data["x"].(float64)
+	y, _ := msg.Data["y"].(float64)
+	w, _ := msg.Data["w"].(float64)
+	h, _ := msg.Data["h"].(float64)
+
+	content := fmt.Sprintf("📷 Person detected!\nClass: %s\nConfidence: %.2f%%\nPosition: (%.0f, %.0f)\nSize: %.0fx%.0f",
+		classInfo, score*100, x, y, w, h)
+
+	metadata := map[string]string{
+		"timestamp": fmt.Sprintf("%.0f", msg.Timestamp),
+		"class_id":  fmt.Sprintf("%.0f", msg.Data["class_id"]),
+		"score":     fmt.Sprintf("%.2f", score),
+		"x":         fmt.Sprintf("%.0f", x),
+		"y":         fmt.Sprintf("%.0f", y),
+		"w":         fmt.Sprintf("%.0f", w),
+		"h":         fmt.Sprintf("%.0f", h),
+		"peer_kind": "channel",
+		"peer_id":   "default",
+	}
+
+	c.HandleMessage(senderID, chatID, content, []string{}, metadata)
+}
+
+func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) {
+	logger.InfoCF("maixcam", "Status update from MaixCam", map[string]interface{}{
+		"status": msg.Data,
+	})
+}
+
+func (c *MaixCamChannel) Stop(ctx context.Context) error {
+	logger.InfoC("maixcam", "Stopping MaixCam channel")
+	c.SetRunning(false)
+
+	if c.listener != nil {
+		c.listener.Close()
+	}
+
+	c.clientsMux.Lock()
+	defer c.clientsMux.Unlock()
+
+	for conn := range c.clients {
+		conn.Close()
+	}
+	c.clients = make(map[net.Conn]bool)
+
+	logger.InfoC("maixcam", "MaixCam channel stopped")
+	return nil
+}
+
+func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("maixcam channel not running")
+	}
+
+	c.clientsMux.RLock()
+	defer c.clientsMux.RUnlock()
+
+	if len(c.clients) == 0 {
+		logger.WarnC("maixcam", "No MaixCam devices connected")
+		return fmt.Errorf("no connected MaixCam devices")
+	}
+
+	response := map[string]interface{}{
+		"type":      "command",
+		"timestamp": float64(0),
+		"message":   msg.Content,
+		"chat_id":   msg.ChatID,
+	}
+
+	data, err := json.Marshal(response)
+	if err != nil {
+		return fmt.Errorf("failed to marshal response: %w", err)
+	}
+
+	var sendErr error
+	for conn := range c.clients {
+		if _, err := conn.Write(data); err != nil {
+			logger.ErrorCF("maixcam", "Failed to send to client", map[string]interface{}{
+				"client": conn.RemoteAddr().String(),
+				"error":  err.Error(),
+			})
+			sendErr = err
+		}
+	}
+
+	return sendErr
+}
diff --git a/pkg/channels/onebot/init.go b/pkg/channels/onebot/init.go
new file mode 100644
index 000000000..84c06dfd6
--- /dev/null
+++ b/pkg/channels/onebot/init.go
@@ -0,0 +1,13 @@
+package onebot
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("onebot", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewOneBotChannel(cfg.Channels.OneBot, b)
+	})
+}
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
new file mode 100644
index 000000000..209f2dc00
--- /dev/null
+++ b/pkg/channels/onebot/onebot.go
@@ -0,0 +1,980 @@
+package onebot
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/gorilla/websocket"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+	"github.com/sipeed/picoclaw/pkg/voice"
+)
+
+type OneBotChannel struct {
+	*channels.BaseChannel
+	config          config.OneBotConfig
+	conn            *websocket.Conn
+	ctx             context.Context
+	cancel          context.CancelFunc
+	dedup           map[string]struct{}
+	dedupRing       []string
+	dedupIdx        int
+	mu              sync.Mutex
+	writeMu         sync.Mutex
+	echoCounter     int64
+	selfID          int64
+	pending         map[string]chan json.RawMessage
+	pendingMu       sync.Mutex
+	transcriber     *voice.GroqTranscriber
+	lastMessageID   sync.Map
+	pendingEmojiMsg sync.Map
+}
+
+type oneBotRawEvent struct {
+	PostType      string          `json:"post_type"`
+	MessageType   string          `json:"message_type"`
+	SubType       string          `json:"sub_type"`
+	MessageID     json.RawMessage `json:"message_id"`
+	UserID        json.RawMessage `json:"user_id"`
+	GroupID       json.RawMessage `json:"group_id"`
+	RawMessage    string          `json:"raw_message"`
+	Message       json.RawMessage `json:"message"`
+	Sender        json.RawMessage `json:"sender"`
+	SelfID        json.RawMessage `json:"self_id"`
+	Time          json.RawMessage `json:"time"`
+	MetaEventType string          `json:"meta_event_type"`
+	NoticeType    string          `json:"notice_type"`
+	Echo          string          `json:"echo"`
+	RetCode       json.RawMessage `json:"retcode"`
+	Status        json.RawMessage `json:"status"`
+	Data          json.RawMessage `json:"data"`
+}
+
+type BotStatus struct {
+	Online bool `json:"online"`
+	Good   bool `json:"good"`
+}
+
+func isAPIResponse(raw json.RawMessage) bool {
+	if len(raw) == 0 {
+		return false
+	}
+	var s string
+	if json.Unmarshal(raw, &s) == nil {
+		return s == "ok" || s == "failed"
+	}
+	var bs BotStatus
+	if json.Unmarshal(raw, &bs) == nil {
+		return bs.Online || bs.Good
+	}
+	return false
+}
+
+type oneBotSender struct {
+	UserID   json.RawMessage `json:"user_id"`
+	Nickname string          `json:"nickname"`
+	Card     string          `json:"card"`
+}
+
+type oneBotAPIRequest struct {
+	Action string      `json:"action"`
+	Params interface{} `json:"params"`
+	Echo   string      `json:"echo,omitempty"`
+}
+
+type oneBotMessageSegment struct {
+	Type string                 `json:"type"`
+	Data map[string]interface{} `json:"data"`
+}
+
+func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*OneBotChannel, error) {
+	base := channels.NewBaseChannel("onebot", cfg, messageBus, cfg.AllowFrom)
+
+	const dedupSize = 1024
+	return &OneBotChannel{
+		BaseChannel: base,
+		config:      cfg,
+		dedup:       make(map[string]struct{}, dedupSize),
+		dedupRing:   make([]string, dedupSize),
+		dedupIdx:    0,
+		pending:     make(map[string]chan json.RawMessage),
+	}, nil
+}
+
+func (c *OneBotChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
+	c.transcriber = transcriber
+}
+
+func (c *OneBotChannel) setMsgEmojiLike(messageID string, emojiID int, set bool) {
+	go func() {
+		_, err := c.sendAPIRequest("set_msg_emoji_like", map[string]interface{}{
+			"message_id": messageID,
+			"emoji_id":   emojiID,
+			"set":        set,
+		}, 5*time.Second)
+		if err != nil {
+			logger.DebugCF("onebot", "Failed to set emoji like", map[string]interface{}{
+				"message_id": messageID,
+				"error":      err.Error(),
+			})
+		}
+	}()
+}
+
+func (c *OneBotChannel) Start(ctx context.Context) error {
+	if c.config.WSUrl == "" {
+		return fmt.Errorf("OneBot ws_url not configured")
+	}
+
+	logger.InfoCF("onebot", "Starting OneBot channel", map[string]interface{}{
+		"ws_url": c.config.WSUrl,
+	})
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	if err := c.connect(); err != nil {
+		logger.WarnCF("onebot", "Initial connection failed, will retry in background", map[string]interface{}{
+			"error": err.Error(),
+		})
+	} else {
+		go c.listen()
+		c.fetchSelfID()
+	}
+
+	if c.config.ReconnectInterval > 0 {
+		go c.reconnectLoop()
+	} else {
+		if c.conn == nil {
+			return fmt.Errorf("failed to connect to OneBot and reconnect is disabled")
+		}
+	}
+
+	c.SetRunning(true)
+	logger.InfoC("onebot", "OneBot channel started successfully")
+
+	return nil
+}
+
+func (c *OneBotChannel) connect() error {
+	dialer := websocket.DefaultDialer
+	dialer.HandshakeTimeout = 10 * time.Second
+
+	header := make(map[string][]string)
+	if c.config.AccessToken != "" {
+		header["Authorization"] = []string{"Bearer " + c.config.AccessToken}
+	}
+
+	conn, _, err := dialer.Dial(c.config.WSUrl, header)
+	if err != nil {
+		return err
+	}
+
+	conn.SetPongHandler(func(appData string) error {
+		_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+		return nil
+	})
+	_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+
+	c.mu.Lock()
+	c.conn = conn
+	c.mu.Unlock()
+
+	go c.pinger(conn)
+
+	logger.InfoC("onebot", "WebSocket connected")
+	return nil
+}
+
+func (c *OneBotChannel) pinger(conn *websocket.Conn) {
+	ticker := time.NewTicker(30 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-ticker.C:
+			c.writeMu.Lock()
+			err := conn.WriteMessage(websocket.PingMessage, nil)
+			c.writeMu.Unlock()
+			if err != nil {
+				logger.DebugCF("onebot", "Ping write failed, stopping pinger", map[string]interface{}{
+					"error": err.Error(),
+				})
+				return
+			}
+		}
+	}
+}
+
+func (c *OneBotChannel) fetchSelfID() {
+	resp, err := c.sendAPIRequest("get_login_info", nil, 5*time.Second)
+	if err != nil {
+		logger.WarnCF("onebot", "Failed to get_login_info", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	type loginInfo struct {
+		UserID   json.RawMessage `json:"user_id"`
+		Nickname string          `json:"nickname"`
+	}
+	for _, extract := range []func() (*loginInfo, error){
+		func() (*loginInfo, error) {
+			var w struct {
+				Data loginInfo `json:"data"`
+			}
+			err := json.Unmarshal(resp, &w)
+			return &w.Data, err
+		},
+		func() (*loginInfo, error) {
+			var f loginInfo
+			err := json.Unmarshal(resp, &f)
+			return &f, err
+		},
+	} {
+		info, err := extract()
+		if err != nil || len(info.UserID) == 0 {
+			continue
+		}
+		if uid, err := parseJSONInt64(info.UserID); err == nil && uid > 0 {
+			atomic.StoreInt64(&c.selfID, uid)
+			logger.InfoCF("onebot", "Bot self ID retrieved", map[string]interface{}{
+				"self_id":  uid,
+				"nickname": info.Nickname,
+			})
+			return
+		}
+	}
+
+	logger.WarnCF("onebot", "Could not parse self ID from get_login_info response", map[string]interface{}{
+		"response": string(resp),
+	})
+}
+
+func (c *OneBotChannel) sendAPIRequest(action string, params interface{}, timeout time.Duration) (json.RawMessage, error) {
+	c.mu.Lock()
+	conn := c.conn
+	c.mu.Unlock()
+
+	if conn == nil {
+		return nil, fmt.Errorf("WebSocket not connected")
+	}
+
+	echo := fmt.Sprintf("api_%d_%d", time.Now().UnixNano(), atomic.AddInt64(&c.echoCounter, 1))
+
+	ch := make(chan json.RawMessage, 1)
+	c.pendingMu.Lock()
+	c.pending[echo] = ch
+	c.pendingMu.Unlock()
+
+	defer func() {
+		c.pendingMu.Lock()
+		delete(c.pending, echo)
+		c.pendingMu.Unlock()
+	}()
+
+	req := oneBotAPIRequest{
+		Action: action,
+		Params: params,
+		Echo:   echo,
+	}
+
+	data, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal API request: %w", err)
+	}
+
+	c.writeMu.Lock()
+	err = conn.WriteMessage(websocket.TextMessage, data)
+	c.writeMu.Unlock()
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to write API request: %w", err)
+	}
+
+	select {
+	case resp := <-ch:
+		return resp, nil
+	case <-time.After(timeout):
+		return nil, fmt.Errorf("API request %s timed out after %v", action, timeout)
+	case <-c.ctx.Done():
+		return nil, fmt.Errorf("context cancelled")
+	}
+}
+
+func (c *OneBotChannel) reconnectLoop() {
+	interval := time.Duration(c.config.ReconnectInterval) * time.Second
+	if interval < 5*time.Second {
+		interval = 5 * time.Second
+	}
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-time.After(interval):
+			c.mu.Lock()
+			conn := c.conn
+			c.mu.Unlock()
+
+			if conn == nil {
+				logger.InfoC("onebot", "Attempting to reconnect...")
+				if err := c.connect(); err != nil {
+					logger.ErrorCF("onebot", "Reconnect failed", map[string]interface{}{
+						"error": err.Error(),
+					})
+				} else {
+					go c.listen()
+					c.fetchSelfID()
+				}
+			}
+		}
+	}
+}
+
+func (c *OneBotChannel) Stop(ctx context.Context) error {
+	logger.InfoC("onebot", "Stopping OneBot channel")
+	c.SetRunning(false)
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	c.pendingMu.Lock()
+	for echo, ch := range c.pending {
+		close(ch)
+		delete(c.pending, echo)
+	}
+	c.pendingMu.Unlock()
+
+	c.mu.Lock()
+	if c.conn != nil {
+		c.conn.Close()
+		c.conn = nil
+	}
+	c.mu.Unlock()
+
+	return nil
+}
+
+func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("OneBot channel not running")
+	}
+
+	c.mu.Lock()
+	conn := c.conn
+	c.mu.Unlock()
+
+	if conn == nil {
+		return fmt.Errorf("OneBot WebSocket not connected")
+	}
+
+	action, params, err := c.buildSendRequest(msg)
+	if err != nil {
+		return err
+	}
+
+	echo := fmt.Sprintf("send_%d", atomic.AddInt64(&c.echoCounter, 1))
+
+	req := oneBotAPIRequest{
+		Action: action,
+		Params: params,
+		Echo:   echo,
+	}
+
+	data, err := json.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("failed to marshal OneBot request: %w", err)
+	}
+
+	c.writeMu.Lock()
+	err = conn.WriteMessage(websocket.TextMessage, data)
+	c.writeMu.Unlock()
+
+	if err != nil {
+		logger.ErrorCF("onebot", "Failed to send message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return err
+	}
+
+	if msgID, ok := c.pendingEmojiMsg.LoadAndDelete(msg.ChatID); ok {
+		if mid, ok := msgID.(string); ok && mid != "" {
+			c.setMsgEmojiLike(mid, 289, false)
+		}
+	}
+
+	return nil
+}
+
+func (c *OneBotChannel) buildMessageSegments(chatID, content string) []oneBotMessageSegment {
+	var segments []oneBotMessageSegment
+
+	if lastMsgID, ok := c.lastMessageID.Load(chatID); ok {
+		if msgID, ok := lastMsgID.(string); ok && msgID != "" {
+			segments = append(segments, oneBotMessageSegment{
+				Type: "reply",
+				Data: map[string]interface{}{"id": msgID},
+			})
+		}
+	}
+
+	segments = append(segments, oneBotMessageSegment{
+		Type: "text",
+		Data: map[string]interface{}{"text": content},
+	})
+
+	return segments
+}
+
+func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, interface{}, error) {
+	chatID := msg.ChatID
+	segments := c.buildMessageSegments(chatID, msg.Content)
+
+	var action, idKey string
+	var rawID string
+	if rest, ok := strings.CutPrefix(chatID, "group:"); ok {
+		action, idKey, rawID = "send_group_msg", "group_id", rest
+	} else if rest, ok := strings.CutPrefix(chatID, "private:"); ok {
+		action, idKey, rawID = "send_private_msg", "user_id", rest
+	} else {
+		action, idKey, rawID = "send_private_msg", "user_id", chatID
+	}
+
+	id, err := strconv.ParseInt(rawID, 10, 64)
+	if err != nil {
+		return "", nil, fmt.Errorf("invalid %s in chatID: %s", idKey, chatID)
+	}
+	return action, map[string]interface{}{idKey: id, "message": segments}, nil
+}
+
+func (c *OneBotChannel) listen() {
+	c.mu.Lock()
+	conn := c.conn
+	c.mu.Unlock()
+
+	if conn == nil {
+		logger.WarnC("onebot", "WebSocket connection is nil, listener exiting")
+		return
+	}
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+			_, message, err := conn.ReadMessage()
+			if err != nil {
+				logger.ErrorCF("onebot", "WebSocket read error", map[string]interface{}{
+					"error": err.Error(),
+				})
+				c.mu.Lock()
+				if c.conn == conn {
+					c.conn.Close()
+					c.conn = nil
+				}
+				c.mu.Unlock()
+				return
+			}
+
+			_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+
+			var raw oneBotRawEvent
+			if err := json.Unmarshal(message, &raw); err != nil {
+				logger.WarnCF("onebot", "Failed to unmarshal raw event", map[string]interface{}{
+					"error":   err.Error(),
+					"payload": string(message),
+				})
+				continue
+			}
+
+			logger.DebugCF("onebot", "WebSocket event", map[string]interface{}{
+				"length":    len(message),
+				"post_type": raw.PostType,
+				"sub_type":  raw.SubType,
+			})
+
+			if raw.Echo != "" {
+				c.pendingMu.Lock()
+				ch, ok := c.pending[raw.Echo]
+				c.pendingMu.Unlock()
+
+				if ok {
+					select {
+					case ch <- message:
+					default:
+					}
+				} else {
+					logger.DebugCF("onebot", "Received API response (no waiter)", map[string]interface{}{
+						"echo":   raw.Echo,
+						"status": string(raw.Status),
+					})
+				}
+				continue
+			}
+
+			if isAPIResponse(raw.Status) {
+				logger.DebugCF("onebot", "Received API response without echo, skipping", map[string]interface{}{
+					"status": string(raw.Status),
+				})
+				continue
+			}
+
+			c.handleRawEvent(&raw)
+		}
+	}
+}
+
+func parseJSONInt64(raw json.RawMessage) (int64, error) {
+	if len(raw) == 0 {
+		return 0, nil
+	}
+
+	var n int64
+	if err := json.Unmarshal(raw, &n); err == nil {
+		return n, nil
+	}
+
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return strconv.ParseInt(s, 10, 64)
+	}
+	return 0, fmt.Errorf("cannot parse as int64: %s", string(raw))
+}
+
+func parseJSONString(raw json.RawMessage) string {
+	if len(raw) == 0 {
+		return ""
+	}
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return s
+	}
+
+	return string(raw)
+}
+
+type parseMessageResult struct {
+	Text           string
+	IsBotMentioned bool
+	Media          []string
+	LocalFiles     []string
+	ReplyTo        string
+}
+
+func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64) parseMessageResult {
+	if len(raw) == 0 {
+		return parseMessageResult{}
+	}
+
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		mentioned := false
+		if selfID > 0 {
+			cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
+			if strings.Contains(s, cqAt) {
+				mentioned = true
+				s = strings.ReplaceAll(s, cqAt, "")
+				s = strings.TrimSpace(s)
+			}
+		}
+		return parseMessageResult{Text: s, IsBotMentioned: mentioned}
+	}
+
+	var segments []map[string]interface{}
+	if err := json.Unmarshal(raw, &segments); err != nil {
+		return parseMessageResult{}
+	}
+
+	var textParts []string
+	mentioned := false
+	selfIDStr := strconv.FormatInt(selfID, 10)
+	var media []string
+	var localFiles []string
+	var replyTo string
+
+	for _, seg := range segments {
+		segType, _ := seg["type"].(string)
+		data, _ := seg["data"].(map[string]interface{})
+
+		switch segType {
+		case "text":
+			if data != nil {
+				if t, ok := data["text"].(string); ok {
+					textParts = append(textParts, t)
+				}
+			}
+
+		case "at":
+			if data != nil && selfID > 0 {
+				qqVal := fmt.Sprintf("%v", data["qq"])
+				if qqVal == selfIDStr || qqVal == "all" {
+					mentioned = true
+				}
+			}
+
+		case "image", "video", "file":
+			if data != nil {
+				url, _ := data["url"].(string)
+				if url != "" {
+					defaults := map[string]string{"image": "image.jpg", "video": "video.mp4", "file": "file"}
+					filename := defaults[segType]
+					if f, ok := data["file"].(string); ok && f != "" {
+						filename = f
+					} else if n, ok := data["name"].(string); ok && n != "" {
+						filename = n
+					}
+					localPath := utils.DownloadFile(url, filename, utils.DownloadOptions{
+						LoggerPrefix: "onebot",
+					})
+					if localPath != "" {
+						media = append(media, localPath)
+						localFiles = append(localFiles, localPath)
+						textParts = append(textParts, fmt.Sprintf("[%s]", segType))
+					}
+				}
+			}
+
+		case "record":
+			if data != nil {
+				url, _ := data["url"].(string)
+				if url != "" {
+					localPath := utils.DownloadFile(url, "voice.amr", utils.DownloadOptions{
+						LoggerPrefix: "onebot",
+					})
+					if localPath != "" {
+						localFiles = append(localFiles, localPath)
+						if c.transcriber != nil && c.transcriber.IsAvailable() {
+							tctx, tcancel := context.WithTimeout(c.ctx, 30*time.Second)
+							result, err := c.transcriber.Transcribe(tctx, localPath)
+							tcancel()
+							if err != nil {
+								logger.WarnCF("onebot", "Voice transcription failed", map[string]interface{}{
+									"error": err.Error(),
+								})
+								textParts = append(textParts, "[voice (transcription failed)]")
+								media = append(media, localPath)
+							} else {
+								textParts = append(textParts, fmt.Sprintf("[voice transcription: %s]", result.Text))
+							}
+						} else {
+							textParts = append(textParts, "[voice]")
+							media = append(media, localPath)
+						}
+					}
+				}
+			}
+
+		case "reply":
+			if data != nil {
+				if id, ok := data["id"]; ok {
+					replyTo = fmt.Sprintf("%v", id)
+				}
+			}
+
+		case "face":
+			if data != nil {
+				faceID, _ := data["id"]
+				textParts = append(textParts, fmt.Sprintf("[face:%v]", faceID))
+			}
+
+		case "forward":
+			textParts = append(textParts, "[forward message]")
+
+		default:
+
+		}
+	}
+
+	return parseMessageResult{
+		Text:           strings.TrimSpace(strings.Join(textParts, "")),
+		IsBotMentioned: mentioned,
+		Media:          media,
+		LocalFiles:     localFiles,
+		ReplyTo:        replyTo,
+	}
+}
+
+func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
+	switch raw.PostType {
+	case "message":
+		if userID, err := parseJSONInt64(raw.UserID); err == nil && userID > 0 {
+			if !c.IsAllowed(strconv.FormatInt(userID, 10)) {
+				logger.DebugCF("onebot", "Message rejected by allowlist", map[string]interface{}{
+					"user_id": userID,
+				})
+				return
+			}
+		}
+		c.handleMessage(raw)
+
+	case "message_sent":
+		logger.DebugCF("onebot", "Bot sent message event", map[string]interface{}{
+			"message_type": raw.MessageType,
+			"message_id":   parseJSONString(raw.MessageID),
+		})
+
+	case "meta_event":
+		c.handleMetaEvent(raw)
+
+	case "notice":
+		c.handleNoticeEvent(raw)
+
+	case "request":
+		logger.DebugCF("onebot", "Request event received", map[string]interface{}{
+			"sub_type": raw.SubType,
+		})
+
+	case "":
+		logger.DebugCF("onebot", "Event with empty post_type (possibly API response)", map[string]interface{}{
+			"echo":   raw.Echo,
+			"status": raw.Status,
+		})
+
+	default:
+		logger.DebugCF("onebot", "Unknown post_type", map[string]interface{}{
+			"post_type": raw.PostType,
+		})
+	}
+}
+
+func (c *OneBotChannel) handleMetaEvent(raw *oneBotRawEvent) {
+	if raw.MetaEventType == "lifecycle" {
+		logger.InfoCF("onebot", "Lifecycle event", map[string]interface{}{"sub_type": raw.SubType})
+	} else if raw.MetaEventType != "heartbeat" {
+		logger.DebugCF("onebot", "Meta event: "+raw.MetaEventType, nil)
+	}
+}
+
+func (c *OneBotChannel) handleNoticeEvent(raw *oneBotRawEvent) {
+	fields := map[string]interface{}{
+		"notice_type": raw.NoticeType,
+		"sub_type":    raw.SubType,
+		"group_id":    parseJSONString(raw.GroupID),
+		"user_id":     parseJSONString(raw.UserID),
+		"message_id":  parseJSONString(raw.MessageID),
+	}
+	switch raw.NoticeType {
+	case "group_recall", "group_increase", "group_decrease",
+		"friend_add", "group_admin", "group_ban":
+		logger.InfoCF("onebot", "Notice: "+raw.NoticeType, fields)
+	default:
+		logger.DebugCF("onebot", "Notice: "+raw.NoticeType, fields)
+	}
+}
+
+func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
+	// Parse fields from raw event
+	userID, err := parseJSONInt64(raw.UserID)
+	if err != nil {
+		logger.WarnCF("onebot", "Failed to parse user_id", map[string]interface{}{
+			"error": err.Error(),
+			"raw":   string(raw.UserID),
+		})
+		return
+	}
+
+	groupID, _ := parseJSONInt64(raw.GroupID)
+	selfID, _ := parseJSONInt64(raw.SelfID)
+	messageID := parseJSONString(raw.MessageID)
+
+	if selfID == 0 {
+		selfID = atomic.LoadInt64(&c.selfID)
+	}
+
+	parsed := c.parseMessageSegments(raw.Message, selfID)
+	isBotMentioned := parsed.IsBotMentioned
+
+	content := raw.RawMessage
+	if content == "" {
+		content = parsed.Text
+	} else if selfID > 0 {
+		cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
+		if strings.Contains(content, cqAt) {
+			isBotMentioned = true
+			content = strings.ReplaceAll(content, cqAt, "")
+			content = strings.TrimSpace(content)
+		}
+	}
+
+	if parsed.Text != "" && content != parsed.Text && (len(parsed.Media) > 0 || parsed.ReplyTo != "") {
+		content = parsed.Text
+	}
+
+	var sender oneBotSender
+	if len(raw.Sender) > 0 {
+		if err := json.Unmarshal(raw.Sender, &sender); err != nil {
+			logger.WarnCF("onebot", "Failed to parse sender", map[string]interface{}{
+				"error":  err.Error(),
+				"sender": string(raw.Sender),
+			})
+		}
+	}
+
+	// Clean up temp files when done
+	if len(parsed.LocalFiles) > 0 {
+		defer func() {
+			for _, f := range parsed.LocalFiles {
+				if err := os.Remove(f); err != nil {
+					logger.DebugCF("onebot", "Failed to remove temp file", map[string]interface{}{
+						"path":  f,
+						"error": err.Error(),
+					})
+				}
+			}
+		}()
+	}
+
+	if c.isDuplicate(messageID) {
+		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]interface{}{
+			"message_id": messageID,
+		})
+		return
+	}
+
+	if content == "" {
+		logger.DebugCF("onebot", "Received empty message, ignoring", map[string]interface{}{
+			"message_id": messageID,
+		})
+		return
+	}
+
+	senderID := strconv.FormatInt(userID, 10)
+	var chatID string
+
+	metadata := map[string]string{
+		"message_id": messageID,
+	}
+
+	if parsed.ReplyTo != "" {
+		metadata["reply_to_message_id"] = parsed.ReplyTo
+	}
+
+	switch raw.MessageType {
+	case "private":
+		chatID = "private:" + senderID
+		metadata["peer_kind"] = "direct"
+		metadata["peer_id"] = senderID
+
+	case "group":
+		groupIDStr := strconv.FormatInt(groupID, 10)
+		chatID = "group:" + groupIDStr
+		metadata["peer_kind"] = "group"
+		metadata["peer_id"] = groupIDStr
+		metadata["group_id"] = groupIDStr
+
+		senderUserID, _ := parseJSONInt64(sender.UserID)
+		if senderUserID > 0 {
+			metadata["sender_user_id"] = strconv.FormatInt(senderUserID, 10)
+		}
+
+		if sender.Card != "" {
+			metadata["sender_name"] = sender.Card
+		} else if sender.Nickname != "" {
+			metadata["sender_name"] = sender.Nickname
+		}
+
+		triggered, strippedContent := c.checkGroupTrigger(content, isBotMentioned)
+		if !triggered {
+			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]interface{}{
+				"sender":       senderID,
+				"group":        groupIDStr,
+				"is_mentioned": isBotMentioned,
+				"content":      truncate(content, 100),
+			})
+			return
+		}
+		content = strippedContent
+
+	default:
+		logger.WarnCF("onebot", "Unknown message type, cannot route", map[string]interface{}{
+			"type":       raw.MessageType,
+			"message_id": messageID,
+			"user_id":    userID,
+		})
+		return
+	}
+
+	logger.InfoCF("onebot", "Received "+raw.MessageType+" message", map[string]interface{}{
+		"sender":      senderID,
+		"chat_id":     chatID,
+		"message_id":  messageID,
+		"length":      len(content),
+		"content":     truncate(content, 100),
+		"media_count": len(parsed.Media),
+	})
+
+	if sender.Nickname != "" {
+		metadata["nickname"] = sender.Nickname
+	}
+
+	c.lastMessageID.Store(chatID, messageID)
+
+	if raw.MessageType == "group" && messageID != "" && messageID != "0" {
+		c.setMsgEmojiLike(messageID, 289, true)
+		c.pendingEmojiMsg.Store(chatID, messageID)
+	}
+
+	c.HandleMessage(senderID, chatID, content, parsed.Media, metadata)
+}
+
+func (c *OneBotChannel) isDuplicate(messageID string) bool {
+	if messageID == "" || messageID == "0" {
+		return false
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if _, exists := c.dedup[messageID]; exists {
+		return true
+	}
+
+	if old := c.dedupRing[c.dedupIdx]; old != "" {
+		delete(c.dedup, old)
+	}
+	c.dedupRing[c.dedupIdx] = messageID
+	c.dedup[messageID] = struct{}{}
+	c.dedupIdx = (c.dedupIdx + 1) % len(c.dedupRing)
+
+	return false
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "..."
+}
+
+func (c *OneBotChannel) checkGroupTrigger(content string, isBotMentioned bool) (triggered bool, strippedContent string) {
+	if isBotMentioned {
+		return true, strings.TrimSpace(content)
+	}
+
+	for _, prefix := range c.config.GroupTriggerPrefix {
+		if prefix == "" {
+			continue
+		}
+		if strings.HasPrefix(content, prefix) {
+			return true, strings.TrimSpace(strings.TrimPrefix(content, prefix))
+		}
+	}
+
+	return false, content
+}
diff --git a/pkg/channels/qq/init.go b/pkg/channels/qq/init.go
new file mode 100644
index 000000000..15b955089
--- /dev/null
+++ b/pkg/channels/qq/init.go
@@ -0,0 +1,13 @@
+package qq
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("qq", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewQQChannel(cfg.Channels.QQ, b)
+	})
+}
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
new file mode 100644
index 000000000..9b07be0cc
--- /dev/null
+++ b/pkg/channels/qq/qq.go
@@ -0,0 +1,248 @@
+package qq
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/tencent-connect/botgo"
+	"github.com/tencent-connect/botgo/dto"
+	"github.com/tencent-connect/botgo/event"
+	"github.com/tencent-connect/botgo/openapi"
+	"github.com/tencent-connect/botgo/token"
+	"golang.org/x/oauth2"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+)
+
+type QQChannel struct {
+	*channels.BaseChannel
+	config         config.QQConfig
+	api            openapi.OpenAPI
+	tokenSource    oauth2.TokenSource
+	ctx            context.Context
+	cancel         context.CancelFunc
+	sessionManager botgo.SessionManager
+	processedIDs   map[string]bool
+	mu             sync.RWMutex
+}
+
+func NewQQChannel(cfg config.QQConfig, messageBus *bus.MessageBus) (*QQChannel, error) {
+	base := channels.NewBaseChannel("qq", cfg, messageBus, cfg.AllowFrom)
+
+	return &QQChannel{
+		BaseChannel:  base,
+		config:       cfg,
+		processedIDs: make(map[string]bool),
+	}, nil
+}
+
+func (c *QQChannel) Start(ctx context.Context) error {
+	if c.config.AppID == "" || c.config.AppSecret == "" {
+		return fmt.Errorf("QQ app_id and app_secret not configured")
+	}
+
+	logger.InfoC("qq", "Starting QQ bot (WebSocket mode)")
+
+	// 创建 token source
+	credentials := &token.QQBotCredentials{
+		AppID:     c.config.AppID,
+		AppSecret: c.config.AppSecret,
+	}
+	c.tokenSource = token.NewQQBotTokenSource(credentials)
+
+	// 创建子 context
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	// 启动自动刷新 token 协程
+	if err := token.StartRefreshAccessToken(c.ctx, c.tokenSource); err != nil {
+		return fmt.Errorf("failed to start token refresh: %w", err)
+	}
+
+	// 初始化 OpenAPI 客户端
+	c.api = botgo.NewOpenAPI(c.config.AppID, c.tokenSource).WithTimeout(5 * time.Second)
+
+	// 注册事件处理器
+	intent := event.RegisterHandlers(
+		c.handleC2CMessage(),
+		c.handleGroupATMessage(),
+	)
+
+	// 获取 WebSocket 接入点
+	wsInfo, err := c.api.WS(c.ctx, nil, "")
+	if err != nil {
+		return fmt.Errorf("failed to get websocket info: %w", err)
+	}
+
+	logger.InfoCF("qq", "Got WebSocket info", map[string]interface{}{
+		"shards": wsInfo.Shards,
+	})
+
+	// 创建并保存 sessionManager
+	c.sessionManager = botgo.NewSessionManager()
+
+	// 在 goroutine 中启动 WebSocket 连接，避免阻塞
+	go func() {
+		if err := c.sessionManager.Start(wsInfo, c.tokenSource, &intent); err != nil {
+			logger.ErrorCF("qq", "WebSocket session error", map[string]interface{}{
+				"error": err.Error(),
+			})
+			c.SetRunning(false)
+		}
+	}()
+
+	c.SetRunning(true)
+	logger.InfoC("qq", "QQ bot started successfully")
+
+	return nil
+}
+
+func (c *QQChannel) Stop(ctx context.Context) error {
+	logger.InfoC("qq", "Stopping QQ bot")
+	c.SetRunning(false)
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	return nil
+}
+
+func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("QQ bot not running")
+	}
+
+	// 构造消息
+	msgToCreate := &dto.MessageToCreate{
+		Content: msg.Content,
+	}
+
+	// C2C 消息发送
+	_, err := c.api.PostC2CMessage(ctx, msg.ChatID, msgToCreate)
+	if err != nil {
+		logger.ErrorCF("qq", "Failed to send C2C message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return err
+	}
+
+	return nil
+}
+
+// handleC2CMessage 处理 QQ 私聊消息
+func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
+	return func(event *dto.WSPayload, data *dto.WSC2CMessageData) error {
+		// 去重检查
+		if c.isDuplicate(data.ID) {
+			return nil
+		}
+
+		// 提取用户信息
+		var senderID string
+		if data.Author != nil && data.Author.ID != "" {
+			senderID = data.Author.ID
+		} else {
+			logger.WarnC("qq", "Received message with no sender ID")
+			return nil
+		}
+
+		// 提取消息内容
+		content := data.Content
+		if content == "" {
+			logger.DebugC("qq", "Received empty message, ignoring")
+			return nil
+		}
+
+		logger.InfoCF("qq", "Received C2C message", map[string]interface{}{
+			"sender": senderID,
+			"length": len(content),
+		})
+
+		// 转发到消息总线
+		metadata := map[string]string{
+			"message_id": data.ID,
+			"peer_kind":  "direct",
+			"peer_id":    senderID,
+		}
+
+		c.HandleMessage(senderID, senderID, content, []string{}, metadata)
+
+		return nil
+	}
+}
+
+// handleGroupATMessage 处理群@消息
+func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
+	return func(event *dto.WSPayload, data *dto.WSGroupATMessageData) error {
+		// 去重检查
+		if c.isDuplicate(data.ID) {
+			return nil
+		}
+
+		// 提取用户信息
+		var senderID string
+		if data.Author != nil && data.Author.ID != "" {
+			senderID = data.Author.ID
+		} else {
+			logger.WarnC("qq", "Received group message with no sender ID")
+			return nil
+		}
+
+		// 提取消息内容（去掉 @ 机器人部分）
+		content := data.Content
+		if content == "" {
+			logger.DebugC("qq", "Received empty group message, ignoring")
+			return nil
+		}
+
+		logger.InfoCF("qq", "Received group AT message", map[string]interface{}{
+			"sender": senderID,
+			"group":  data.GroupID,
+			"length": len(content),
+		})
+
+		// 转发到消息总线（使用 GroupID 作为 ChatID）
+		metadata := map[string]string{
+			"message_id": data.ID,
+			"group_id":   data.GroupID,
+			"peer_kind":  "group",
+			"peer_id":    data.GroupID,
+		}
+
+		c.HandleMessage(senderID, data.GroupID, content, []string{}, metadata)
+
+		return nil
+	}
+}
+
+// isDuplicate 检查消息是否重复
+func (c *QQChannel) isDuplicate(messageID string) bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.processedIDs[messageID] {
+		return true
+	}
+
+	c.processedIDs[messageID] = true
+
+	// 简单清理：限制 map 大小
+	if len(c.processedIDs) > 10000 {
+		// 清空一半
+		count := 0
+		for id := range c.processedIDs {
+			if count >= 5000 {
+				break
+			}
+			delete(c.processedIDs, id)
+			count++
+		}
+	}
+
+	return false
+}
diff --git a/pkg/channels/slack/init.go b/pkg/channels/slack/init.go
new file mode 100644
index 000000000..c131bb291
--- /dev/null
+++ b/pkg/channels/slack/init.go
@@ -0,0 +1,13 @@
+package slack
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("slack", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewSlackChannel(cfg.Channels.Slack, b)
+	})
+}
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
new file mode 100644
index 000000000..dc5190fc9
--- /dev/null
+++ b/pkg/channels/slack/slack.go
@@ -0,0 +1,444 @@
+package slack
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/slack-go/slack"
+	"github.com/slack-go/slack/slackevents"
+	"github.com/slack-go/slack/socketmode"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+	"github.com/sipeed/picoclaw/pkg/voice"
+)
+
+type SlackChannel struct {
+	*channels.BaseChannel
+	config       config.SlackConfig
+	api          *slack.Client
+	socketClient *socketmode.Client
+	botUserID    string
+	teamID       string
+	transcriber  *voice.GroqTranscriber
+	ctx          context.Context
+	cancel       context.CancelFunc
+	pendingAcks  sync.Map
+}
+
+type slackMessageRef struct {
+	ChannelID string
+	Timestamp string
+}
+
+func NewSlackChannel(cfg config.SlackConfig, messageBus *bus.MessageBus) (*SlackChannel, error) {
+	if cfg.BotToken == "" || cfg.AppToken == "" {
+		return nil, fmt.Errorf("slack bot_token and app_token are required")
+	}
+
+	api := slack.New(
+		cfg.BotToken,
+		slack.OptionAppLevelToken(cfg.AppToken),
+	)
+
+	socketClient := socketmode.New(api)
+
+	base := channels.NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom)
+
+	return &SlackChannel{
+		BaseChannel:  base,
+		config:       cfg,
+		api:          api,
+		socketClient: socketClient,
+	}, nil
+}
+
+func (c *SlackChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
+	c.transcriber = transcriber
+}
+
+func (c *SlackChannel) Start(ctx context.Context) error {
+	logger.InfoC("slack", "Starting Slack channel (Socket Mode)")
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	authResp, err := c.api.AuthTest()
+	if err != nil {
+		return fmt.Errorf("slack auth test failed: %w", err)
+	}
+	c.botUserID = authResp.UserID
+	c.teamID = authResp.TeamID
+
+	logger.InfoCF("slack", "Slack bot connected", map[string]interface{}{
+		"bot_user_id": c.botUserID,
+		"team":        authResp.Team,
+	})
+
+	go c.eventLoop()
+
+	go func() {
+		if err := c.socketClient.RunContext(c.ctx); err != nil {
+			if c.ctx.Err() == nil {
+				logger.ErrorCF("slack", "Socket Mode connection error", map[string]interface{}{
+					"error": err.Error(),
+				})
+			}
+		}
+	}()
+
+	c.SetRunning(true)
+	logger.InfoC("slack", "Slack channel started (Socket Mode)")
+	return nil
+}
+
+func (c *SlackChannel) Stop(ctx context.Context) error {
+	logger.InfoC("slack", "Stopping Slack channel")
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	c.SetRunning(false)
+	logger.InfoC("slack", "Slack channel stopped")
+	return nil
+}
+
+func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("slack channel not running")
+	}
+
+	channelID, threadTS := parseSlackChatID(msg.ChatID)
+	if channelID == "" {
+		return fmt.Errorf("invalid slack chat ID: %s", msg.ChatID)
+	}
+
+	opts := []slack.MsgOption{
+		slack.MsgOptionText(msg.Content, false),
+	}
+
+	if threadTS != "" {
+		opts = append(opts, slack.MsgOptionTS(threadTS))
+	}
+
+	_, _, err := c.api.PostMessageContext(ctx, channelID, opts...)
+	if err != nil {
+		return fmt.Errorf("failed to send slack message: %w", err)
+	}
+
+	if ref, ok := c.pendingAcks.LoadAndDelete(msg.ChatID); ok {
+		msgRef := ref.(slackMessageRef)
+		c.api.AddReaction("white_check_mark", slack.ItemRef{
+			Channel:   msgRef.ChannelID,
+			Timestamp: msgRef.Timestamp,
+		})
+	}
+
+	logger.DebugCF("slack", "Message sent", map[string]interface{}{
+		"channel_id": channelID,
+		"thread_ts":  threadTS,
+	})
+
+	return nil
+}
+
+func (c *SlackChannel) eventLoop() {
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case event, ok := <-c.socketClient.Events:
+			if !ok {
+				return
+			}
+			switch event.Type {
+			case socketmode.EventTypeEventsAPI:
+				c.handleEventsAPI(event)
+			case socketmode.EventTypeSlashCommand:
+				c.handleSlashCommand(event)
+			case socketmode.EventTypeInteractive:
+				if event.Request != nil {
+					c.socketClient.Ack(*event.Request)
+				}
+			}
+		}
+	}
+}
+
+func (c *SlackChannel) handleEventsAPI(event socketmode.Event) {
+	if event.Request != nil {
+		c.socketClient.Ack(*event.Request)
+	}
+
+	eventsAPIEvent, ok := event.Data.(slackevents.EventsAPIEvent)
+	if !ok {
+		return
+	}
+
+	switch ev := eventsAPIEvent.InnerEvent.Data.(type) {
+	case *slackevents.MessageEvent:
+		c.handleMessageEvent(ev)
+	case *slackevents.AppMentionEvent:
+		c.handleAppMention(ev)
+	}
+}
+
+func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
+	if ev.User == c.botUserID || ev.User == "" {
+		return
+	}
+	if ev.BotID != "" {
+		return
+	}
+	if ev.SubType != "" && ev.SubType != "file_share" {
+		return
+	}
+
+	// 检查白名单，避免为被拒绝的用户下载附件
+	if !c.IsAllowed(ev.User) {
+		logger.DebugCF("slack", "Message rejected by allowlist", map[string]interface{}{
+			"user_id": ev.User,
+		})
+		return
+	}
+
+	senderID := ev.User
+	channelID := ev.Channel
+	threadTS := ev.ThreadTimeStamp
+	messageTS := ev.TimeStamp
+
+	chatID := channelID
+	if threadTS != "" {
+		chatID = channelID + "/" + threadTS
+	}
+
+	c.api.AddReaction("eyes", slack.ItemRef{
+		Channel:   channelID,
+		Timestamp: messageTS,
+	})
+
+	c.pendingAcks.Store(chatID, slackMessageRef{
+		ChannelID: channelID,
+		Timestamp: messageTS,
+	})
+
+	content := ev.Text
+	content = c.stripBotMention(content)
+
+	var mediaPaths []string
+	localFiles := []string{} // 跟踪需要清理的本地文件
+
+	// 确保临时文件在函数返回时被清理
+	defer func() {
+		for _, file := range localFiles {
+			if err := os.Remove(file); err != nil {
+				logger.DebugCF("slack", "Failed to cleanup temp file", map[string]interface{}{
+					"file":  file,
+					"error": err.Error(),
+				})
+			}
+		}
+	}()
+
+	if ev.Message != nil && len(ev.Message.Files) > 0 {
+		for _, file := range ev.Message.Files {
+			localPath := c.downloadSlackFile(file)
+			if localPath == "" {
+				continue
+			}
+			localFiles = append(localFiles, localPath)
+			mediaPaths = append(mediaPaths, localPath)
+
+			if utils.IsAudioFile(file.Name, file.Mimetype) && c.transcriber != nil && c.transcriber.IsAvailable() {
+				ctx, cancel := context.WithTimeout(c.ctx, 30*time.Second)
+				defer cancel()
+				result, err := c.transcriber.Transcribe(ctx, localPath)
+
+				if err != nil {
+					logger.ErrorCF("slack", "Voice transcription failed", map[string]interface{}{"error": err.Error()})
+					content += fmt.Sprintf("\n[audio: %s (transcription failed)]", file.Name)
+				} else {
+					content += fmt.Sprintf("\n[voice transcription: %s]", result.Text)
+				}
+			} else {
+				content += fmt.Sprintf("\n[file: %s]", file.Name)
+			}
+		}
+	}
+
+	if strings.TrimSpace(content) == "" {
+		return
+	}
+
+	peerKind := "channel"
+	peerID := channelID
+	if strings.HasPrefix(channelID, "D") {
+		peerKind = "direct"
+		peerID = senderID
+	}
+
+	metadata := map[string]string{
+		"message_ts": messageTS,
+		"channel_id": channelID,
+		"thread_ts":  threadTS,
+		"platform":   "slack",
+		"peer_kind":  peerKind,
+		"peer_id":    peerID,
+		"team_id":    c.teamID,
+	}
+
+	logger.DebugCF("slack", "Received message", map[string]interface{}{
+		"sender_id":  senderID,
+		"chat_id":    chatID,
+		"preview":    utils.Truncate(content, 50),
+		"has_thread": threadTS != "",
+	})
+
+	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+}
+
+func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
+	if ev.User == c.botUserID {
+		return
+	}
+
+	if !c.IsAllowed(ev.User) {
+		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]interface{}{
+			"user_id": ev.User,
+		})
+		return
+	}
+
+	senderID := ev.User
+	channelID := ev.Channel
+	threadTS := ev.ThreadTimeStamp
+	messageTS := ev.TimeStamp
+
+	var chatID string
+	if threadTS != "" {
+		chatID = channelID + "/" + threadTS
+	} else {
+		chatID = channelID + "/" + messageTS
+	}
+
+	c.api.AddReaction("eyes", slack.ItemRef{
+		Channel:   channelID,
+		Timestamp: messageTS,
+	})
+
+	c.pendingAcks.Store(chatID, slackMessageRef{
+		ChannelID: channelID,
+		Timestamp: messageTS,
+	})
+
+	content := c.stripBotMention(ev.Text)
+
+	if strings.TrimSpace(content) == "" {
+		return
+	}
+
+	mentionPeerKind := "channel"
+	mentionPeerID := channelID
+	if strings.HasPrefix(channelID, "D") {
+		mentionPeerKind = "direct"
+		mentionPeerID = senderID
+	}
+
+	metadata := map[string]string{
+		"message_ts": messageTS,
+		"channel_id": channelID,
+		"thread_ts":  threadTS,
+		"platform":   "slack",
+		"is_mention": "true",
+		"peer_kind":  mentionPeerKind,
+		"peer_id":    mentionPeerID,
+		"team_id":    c.teamID,
+	}
+
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+}
+
+func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
+	cmd, ok := event.Data.(slack.SlashCommand)
+	if !ok {
+		return
+	}
+
+	if event.Request != nil {
+		c.socketClient.Ack(*event.Request)
+	}
+
+	if !c.IsAllowed(cmd.UserID) {
+		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]interface{}{
+			"user_id": cmd.UserID,
+		})
+		return
+	}
+
+	senderID := cmd.UserID
+	channelID := cmd.ChannelID
+	chatID := channelID
+	content := cmd.Text
+
+	if strings.TrimSpace(content) == "" {
+		content = "help"
+	}
+
+	metadata := map[string]string{
+		"channel_id": channelID,
+		"platform":   "slack",
+		"is_command": "true",
+		"trigger_id": cmd.TriggerID,
+		"peer_kind":  "channel",
+		"peer_id":    channelID,
+		"team_id":    c.teamID,
+	}
+
+	logger.DebugCF("slack", "Slash command received", map[string]interface{}{
+		"sender_id": senderID,
+		"command":   cmd.Command,
+		"text":      utils.Truncate(content, 50),
+	})
+
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+}
+
+func (c *SlackChannel) downloadSlackFile(file slack.File) string {
+	downloadURL := file.URLPrivateDownload
+	if downloadURL == "" {
+		downloadURL = file.URLPrivate
+	}
+	if downloadURL == "" {
+		logger.ErrorCF("slack", "No download URL for file", map[string]interface{}{"file_id": file.ID})
+		return ""
+	}
+
+	return utils.DownloadFile(downloadURL, file.Name, utils.DownloadOptions{
+		LoggerPrefix: "slack",
+		ExtraHeaders: map[string]string{
+			"Authorization": "Bearer " + c.config.BotToken,
+		},
+	})
+}
+
+func (c *SlackChannel) stripBotMention(text string) string {
+	mention := fmt.Sprintf("<@%s>", c.botUserID)
+	text = strings.ReplaceAll(text, mention, "")
+	return strings.TrimSpace(text)
+}
+
+func parseSlackChatID(chatID string) (channelID, threadTS string) {
+	parts := strings.SplitN(chatID, "/", 2)
+	channelID = parts[0]
+	if len(parts) > 1 {
+		threadTS = parts[1]
+	}
+	return
+}
diff --git a/pkg/channels/slack/slack_test.go b/pkg/channels/slack/slack_test.go
new file mode 100644
index 000000000..30e0d2d73
--- /dev/null
+++ b/pkg/channels/slack/slack_test.go
@@ -0,0 +1,174 @@
+package slack
+
+import (
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func TestParseSlackChatID(t *testing.T) {
+	tests := []struct {
+		name       string
+		chatID     string
+		wantChanID string
+		wantThread string
+	}{
+		{
+			name:       "channel only",
+			chatID:     "C123456",
+			wantChanID: "C123456",
+			wantThread: "",
+		},
+		{
+			name:       "channel with thread",
+			chatID:     "C123456/1234567890.123456",
+			wantChanID: "C123456",
+			wantThread: "1234567890.123456",
+		},
+		{
+			name:       "DM channel",
+			chatID:     "D987654",
+			wantChanID: "D987654",
+			wantThread: "",
+		},
+		{
+			name:       "empty string",
+			chatID:     "",
+			wantChanID: "",
+			wantThread: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			chanID, threadTS := parseSlackChatID(tt.chatID)
+			if chanID != tt.wantChanID {
+				t.Errorf("parseSlackChatID(%q) channelID = %q, want %q", tt.chatID, chanID, tt.wantChanID)
+			}
+			if threadTS != tt.wantThread {
+				t.Errorf("parseSlackChatID(%q) threadTS = %q, want %q", tt.chatID, threadTS, tt.wantThread)
+			}
+		})
+	}
+}
+
+func TestStripBotMention(t *testing.T) {
+	ch := &SlackChannel{botUserID: "U12345BOT"}
+
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "mention at start",
+			input: "<@U12345BOT> hello there",
+			want:  "hello there",
+		},
+		{
+			name:  "mention in middle",
+			input: "hey <@U12345BOT> can you help",
+			want:  "hey  can you help",
+		},
+		{
+			name:  "no mention",
+			input: "hello world",
+			want:  "hello world",
+		},
+		{
+			name:  "empty string",
+			input: "",
+			want:  "",
+		},
+		{
+			name:  "only mention",
+			input: "<@U12345BOT>",
+			want:  "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := ch.stripBotMention(tt.input)
+			if got != tt.want {
+				t.Errorf("stripBotMention(%q) = %q, want %q", tt.input, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewSlackChannel(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("missing bot token", func(t *testing.T) {
+		cfg := config.SlackConfig{
+			BotToken: "",
+			AppToken: "xapp-test",
+		}
+		_, err := NewSlackChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing bot_token, got nil")
+		}
+	})
+
+	t.Run("missing app token", func(t *testing.T) {
+		cfg := config.SlackConfig{
+			BotToken: "xoxb-test",
+			AppToken: "",
+		}
+		_, err := NewSlackChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing app_token, got nil")
+		}
+	})
+
+	t.Run("valid config", func(t *testing.T) {
+		cfg := config.SlackConfig{
+			BotToken:  "xoxb-test",
+			AppToken:  "xapp-test",
+			AllowFrom: []string{"U123"},
+		}
+		ch, err := NewSlackChannel(cfg, msgBus)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if ch.Name() != "slack" {
+			t.Errorf("Name() = %q, want %q", ch.Name(), "slack")
+		}
+		if ch.IsRunning() {
+			t.Error("new channel should not be running")
+		}
+	})
+}
+
+func TestSlackChannelIsAllowed(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("empty allowlist allows all", func(t *testing.T) {
+		cfg := config.SlackConfig{
+			BotToken:  "xoxb-test",
+			AppToken:  "xapp-test",
+			AllowFrom: []string{},
+		}
+		ch, _ := NewSlackChannel(cfg, msgBus)
+		if !ch.IsAllowed("U_ANYONE") {
+			t.Error("empty allowlist should allow all users")
+		}
+	})
+
+	t.Run("allowlist restricts users", func(t *testing.T) {
+		cfg := config.SlackConfig{
+			BotToken:  "xoxb-test",
+			AppToken:  "xapp-test",
+			AllowFrom: []string{"U_ALLOWED"},
+		}
+		ch, _ := NewSlackChannel(cfg, msgBus)
+		if !ch.IsAllowed("U_ALLOWED") {
+			t.Error("allowed user should pass allowlist check")
+		}
+		if ch.IsAllowed("U_BLOCKED") {
+			t.Error("non-allowed user should be blocked")
+		}
+	})
+}
diff --git a/pkg/channels/telegram/init.go b/pkg/channels/telegram/init.go
new file mode 100644
index 000000000..ac87bb805
--- /dev/null
+++ b/pkg/channels/telegram/init.go
@@ -0,0 +1,13 @@
+package telegram
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("telegram", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewTelegramChannel(cfg, b)
+	})
+}
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
new file mode 100644
index 000000000..f4c5108df
--- /dev/null
+++ b/pkg/channels/telegram/telegram.go
@@ -0,0 +1,526 @@
+package telegram
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	th "github.com/mymmrac/telego/telegohandler"
+
+	"github.com/mymmrac/telego"
+	"github.com/mymmrac/telego/telegohandler"
+	tu "github.com/mymmrac/telego/telegoutil"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+	"github.com/sipeed/picoclaw/pkg/voice"
+)
+
+type TelegramChannel struct {
+	*channels.BaseChannel
+	bot          *telego.Bot
+	commands     TelegramCommander
+	config       *config.Config
+	chatIDs      map[string]int64
+	transcriber  *voice.GroqTranscriber
+	placeholders sync.Map // chatID -> messageID
+	stopThinking sync.Map // chatID -> thinkingCancel
+}
+
+type thinkingCancel struct {
+	fn context.CancelFunc
+}
+
+func (c *thinkingCancel) Cancel() {
+	if c != nil && c.fn != nil {
+		c.fn()
+	}
+}
+
+func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChannel, error) {
+	var opts []telego.BotOption
+	telegramCfg := cfg.Channels.Telegram
+
+	if telegramCfg.Proxy != "" {
+		proxyURL, parseErr := url.Parse(telegramCfg.Proxy)
+		if parseErr != nil {
+			return nil, fmt.Errorf("invalid proxy URL %q: %w", telegramCfg.Proxy, parseErr)
+		}
+		opts = append(opts, telego.WithHTTPClient(&http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyURL(proxyURL),
+			},
+		}))
+	} else if os.Getenv("HTTP_PROXY") != "" || os.Getenv("HTTPS_PROXY") != "" {
+		// Use environment proxy if configured
+		opts = append(opts, telego.WithHTTPClient(&http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		}))
+	}
+
+	bot, err := telego.NewBot(telegramCfg.Token, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create telegram bot: %w", err)
+	}
+
+	base := channels.NewBaseChannel("telegram", telegramCfg, bus, telegramCfg.AllowFrom)
+
+	return &TelegramChannel{
+		BaseChannel:  base,
+		commands:     NewTelegramCommands(bot, cfg),
+		bot:          bot,
+		config:       cfg,
+		chatIDs:      make(map[string]int64),
+		transcriber:  nil,
+		placeholders: sync.Map{},
+		stopThinking: sync.Map{},
+	}, nil
+}
+
+func (c *TelegramChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
+	c.transcriber = transcriber
+}
+
+func (c *TelegramChannel) Start(ctx context.Context) error {
+	logger.InfoC("telegram", "Starting Telegram bot (polling mode)...")
+
+	updates, err := c.bot.UpdatesViaLongPolling(ctx, &telego.GetUpdatesParams{
+		Timeout: 30,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to start long polling: %w", err)
+	}
+
+	bh, err := telegohandler.NewBotHandler(c.bot, updates)
+	if err != nil {
+		return fmt.Errorf("failed to create bot handler: %w", err)
+	}
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		c.commands.Help(ctx, message)
+		return nil
+	}, th.CommandEqual("help"))
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.Start(ctx, message)
+	}, th.CommandEqual("start"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.Show(ctx, message)
+	}, th.CommandEqual("show"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.List(ctx, message)
+	}, th.CommandEqual("list"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.handleMessage(ctx, &message)
+	}, th.AnyMessage())
+
+	c.SetRunning(true)
+	logger.InfoCF("telegram", "Telegram bot connected", map[string]interface{}{
+		"username": c.bot.Username(),
+	})
+
+	go bh.Start()
+
+	go func() {
+		<-ctx.Done()
+		bh.Stop()
+	}()
+
+	return nil
+}
+func (c *TelegramChannel) Stop(ctx context.Context) error {
+	logger.InfoC("telegram", "Stopping Telegram bot...")
+	c.SetRunning(false)
+	return nil
+}
+
+func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("telegram bot not running")
+	}
+
+	chatID, err := parseChatID(msg.ChatID)
+	if err != nil {
+		return fmt.Errorf("invalid chat ID: %w", err)
+	}
+
+	// Stop thinking animation
+	if stop, ok := c.stopThinking.Load(msg.ChatID); ok {
+		if cf, ok := stop.(*thinkingCancel); ok && cf != nil {
+			cf.Cancel()
+		}
+		c.stopThinking.Delete(msg.ChatID)
+	}
+
+	htmlContent := markdownToTelegramHTML(msg.Content)
+
+	// Try to edit placeholder
+	if pID, ok := c.placeholders.Load(msg.ChatID); ok {
+		c.placeholders.Delete(msg.ChatID)
+		editMsg := tu.EditMessageText(tu.ID(chatID), pID.(int), htmlContent)
+		editMsg.ParseMode = telego.ModeHTML
+
+		if _, err = c.bot.EditMessageText(ctx, editMsg); err == nil {
+			return nil
+		}
+		// Fallback to new message if edit fails
+	}
+
+	tgMsg := tu.Message(tu.ID(chatID), htmlContent)
+	tgMsg.ParseMode = telego.ModeHTML
+
+	if _, err = c.bot.SendMessage(ctx, tgMsg); err != nil {
+		logger.ErrorCF("telegram", "HTML parse failed, falling back to plain text", map[string]interface{}{
+			"error": err.Error(),
+		})
+		tgMsg.ParseMode = ""
+		_, err = c.bot.SendMessage(ctx, tgMsg)
+		return err
+	}
+
+	return nil
+}
+
+func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Message) error {
+	if message == nil {
+		return fmt.Errorf("message is nil")
+	}
+
+	user := message.From
+	if user == nil {
+		return fmt.Errorf("message sender (user) is nil")
+	}
+
+	senderID := fmt.Sprintf("%d", user.ID)
+	if user.Username != "" {
+		senderID = fmt.Sprintf("%d|%s", user.ID, user.Username)
+	}
+
+	// 检查白名单，避免为被拒绝的用户下载附件
+	if !c.IsAllowed(senderID) {
+		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]interface{}{
+			"user_id": senderID,
+		})
+		return nil
+	}
+
+	chatID := message.Chat.ID
+	c.chatIDs[senderID] = chatID
+
+	content := ""
+	mediaPaths := []string{}
+	localFiles := []string{} // 跟踪需要清理的本地文件
+
+	// 确保临时文件在函数返回时被清理
+	defer func() {
+		for _, file := range localFiles {
+			if err := os.Remove(file); err != nil {
+				logger.DebugCF("telegram", "Failed to cleanup temp file", map[string]interface{}{
+					"file":  file,
+					"error": err.Error(),
+				})
+			}
+		}
+	}()
+
+	if message.Text != "" {
+		content += message.Text
+	}
+
+	if message.Caption != "" {
+		if content != "" {
+			content += "\n"
+		}
+		content += message.Caption
+	}
+
+	if len(message.Photo) > 0 {
+		photo := message.Photo[len(message.Photo)-1]
+		photoPath := c.downloadPhoto(ctx, photo.FileID)
+		if photoPath != "" {
+			localFiles = append(localFiles, photoPath)
+			mediaPaths = append(mediaPaths, photoPath)
+			if content != "" {
+				content += "\n"
+			}
+			content += "[image: photo]"
+		}
+	}
+
+	if message.Voice != nil {
+		voicePath := c.downloadFile(ctx, message.Voice.FileID, ".ogg")
+		if voicePath != "" {
+			localFiles = append(localFiles, voicePath)
+			mediaPaths = append(mediaPaths, voicePath)
+
+			transcribedText := ""
+			if c.transcriber != nil && c.transcriber.IsAvailable() {
+				ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+				defer cancel()
+
+				result, err := c.transcriber.Transcribe(ctx, voicePath)
+				if err != nil {
+					logger.ErrorCF("telegram", "Voice transcription failed", map[string]interface{}{
+						"error": err.Error(),
+						"path":  voicePath,
+					})
+					transcribedText = "[voice (transcription failed)]"
+				} else {
+					transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
+					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]interface{}{
+						"text": result.Text,
+					})
+				}
+			} else {
+				transcribedText = "[voice]"
+			}
+
+			if content != "" {
+				content += "\n"
+			}
+			content += transcribedText
+		}
+	}
+
+	if message.Audio != nil {
+		audioPath := c.downloadFile(ctx, message.Audio.FileID, ".mp3")
+		if audioPath != "" {
+			localFiles = append(localFiles, audioPath)
+			mediaPaths = append(mediaPaths, audioPath)
+			if content != "" {
+				content += "\n"
+			}
+			content += "[audio]"
+		}
+	}
+
+	if message.Document != nil {
+		docPath := c.downloadFile(ctx, message.Document.FileID, "")
+		if docPath != "" {
+			localFiles = append(localFiles, docPath)
+			mediaPaths = append(mediaPaths, docPath)
+			if content != "" {
+				content += "\n"
+			}
+			content += "[file]"
+		}
+	}
+
+	if content == "" {
+		content = "[empty message]"
+	}
+
+	logger.DebugCF("telegram", "Received message", map[string]interface{}{
+		"sender_id": senderID,
+		"chat_id":   fmt.Sprintf("%d", chatID),
+		"preview":   utils.Truncate(content, 50),
+	})
+
+	// Thinking indicator
+	err := c.bot.SendChatAction(ctx, tu.ChatAction(tu.ID(chatID), telego.ChatActionTyping))
+	if err != nil {
+		logger.ErrorCF("telegram", "Failed to send chat action", map[string]interface{}{
+			"error": err.Error(),
+		})
+	}
+
+	// Stop any previous thinking animation
+	chatIDStr := fmt.Sprintf("%d", chatID)
+	if prevStop, ok := c.stopThinking.Load(chatIDStr); ok {
+		if cf, ok := prevStop.(*thinkingCancel); ok && cf != nil {
+			cf.Cancel()
+		}
+	}
+
+	// Create cancel function for thinking state
+	_, thinkCancel := context.WithTimeout(ctx, 5*time.Minute)
+	c.stopThinking.Store(chatIDStr, &thinkingCancel{fn: thinkCancel})
+
+	pMsg, err := c.bot.SendMessage(ctx, tu.Message(tu.ID(chatID), "Thinking... 💭"))
+	if err == nil {
+		pID := pMsg.MessageID
+		c.placeholders.Store(chatIDStr, pID)
+	}
+
+	peerKind := "direct"
+	peerID := fmt.Sprintf("%d", user.ID)
+	if message.Chat.Type != "private" {
+		peerKind = "group"
+		peerID = fmt.Sprintf("%d", chatID)
+	}
+
+	metadata := map[string]string{
+		"message_id": fmt.Sprintf("%d", message.MessageID),
+		"user_id":    fmt.Sprintf("%d", user.ID),
+		"username":   user.Username,
+		"first_name": user.FirstName,
+		"is_group":   fmt.Sprintf("%t", message.Chat.Type != "private"),
+		"peer_kind":  peerKind,
+		"peer_id":    peerID,
+	}
+
+	c.HandleMessage(fmt.Sprintf("%d", user.ID), fmt.Sprintf("%d", chatID), content, mediaPaths, metadata)
+	return nil
+}
+
+func (c *TelegramChannel) downloadPhoto(ctx context.Context, fileID string) string {
+	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
+	if err != nil {
+		logger.ErrorCF("telegram", "Failed to get photo file", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return ""
+	}
+
+	return c.downloadFileWithInfo(file, ".jpg")
+}
+
+func (c *TelegramChannel) downloadFileWithInfo(file *telego.File, ext string) string {
+	if file.FilePath == "" {
+		return ""
+	}
+
+	url := c.bot.FileDownloadURL(file.FilePath)
+	logger.DebugCF("telegram", "File URL", map[string]interface{}{"url": url})
+
+	// Use FilePath as filename for better identification
+	filename := file.FilePath + ext
+	return utils.DownloadFile(url, filename, utils.DownloadOptions{
+		LoggerPrefix: "telegram",
+	})
+}
+
+func (c *TelegramChannel) downloadFile(ctx context.Context, fileID, ext string) string {
+	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
+	if err != nil {
+		logger.ErrorCF("telegram", "Failed to get file", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return ""
+	}
+
+	return c.downloadFileWithInfo(file, ext)
+}
+
+func parseChatID(chatIDStr string) (int64, error) {
+	var id int64
+	_, err := fmt.Sscanf(chatIDStr, "%d", &id)
+	return id, err
+}
+
+func markdownToTelegramHTML(text string) string {
+	if text == "" {
+		return ""
+	}
+
+	codeBlocks := extractCodeBlocks(text)
+	text = codeBlocks.text
+
+	inlineCodes := extractInlineCodes(text)
+	text = inlineCodes.text
+
+	text = regexp.MustCompile(`^#{1,6}\s+(.+)$`).ReplaceAllString(text, "$1")
+
+	text = regexp.MustCompile(`^>\s*(.*)$`).ReplaceAllString(text, "$1")
+
+	text = escapeHTML(text)
+
+	text = regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`).ReplaceAllString(text, `<a href="$2">$1</a>`)
+
+	text = regexp.MustCompile(`\*\*(.+?)\*\*`).ReplaceAllString(text, "<b>$1</b>")
+
+	text = regexp.MustCompile(`__(.+?)__`).ReplaceAllString(text, "<b>$1</b>")
+
+	reItalic := regexp.MustCompile(`_([^_]+)_`)
+	text = reItalic.ReplaceAllStringFunc(text, func(s string) string {
+		match := reItalic.FindStringSubmatch(s)
+		if len(match) < 2 {
+			return s
+		}
+		return "<i>" + match[1] + "</i>"
+	})
+
+	text = regexp.MustCompile(`~~(.+?)~~`).ReplaceAllString(text, "<s>$1</s>")
+
+	text = regexp.MustCompile(`^[-*]\s+`).ReplaceAllString(text, "• ")
+
+	for i, code := range inlineCodes.codes {
+		escaped := escapeHTML(code)
+		text = strings.ReplaceAll(text, fmt.Sprintf("\x00IC%d\x00", i), fmt.Sprintf("<code>%s</code>", escaped))
+	}
+
+	for i, code := range codeBlocks.codes {
+		escaped := escapeHTML(code)
+		text = strings.ReplaceAll(text, fmt.Sprintf("\x00CB%d\x00", i), fmt.Sprintf("<pre><code>%s</code></pre>", escaped))
+	}
+
+	return text
+}
+
+type codeBlockMatch struct {
+	text  string
+	codes []string
+}
+
+func extractCodeBlocks(text string) codeBlockMatch {
+	re := regexp.MustCompile("```[\\w]*\\n?([\\s\\S]*?)```")
+	matches := re.FindAllStringSubmatch(text, -1)
+
+	codes := make([]string, 0, len(matches))
+	for _, match := range matches {
+		codes = append(codes, match[1])
+	}
+
+	i := 0
+	text = re.ReplaceAllStringFunc(text, func(m string) string {
+		placeholder := fmt.Sprintf("\x00CB%d\x00", i)
+		i++
+		return placeholder
+	})
+
+	return codeBlockMatch{text: text, codes: codes}
+}
+
+type inlineCodeMatch struct {
+	text  string
+	codes []string
+}
+
+func extractInlineCodes(text string) inlineCodeMatch {
+	re := regexp.MustCompile("`([^`]+)`")
+	matches := re.FindAllStringSubmatch(text, -1)
+
+	codes := make([]string, 0, len(matches))
+	for _, match := range matches {
+		codes = append(codes, match[1])
+	}
+
+	i := 0
+	text = re.ReplaceAllStringFunc(text, func(m string) string {
+		placeholder := fmt.Sprintf("\x00IC%d\x00", i)
+		i++
+		return placeholder
+	})
+
+	return inlineCodeMatch{text: text, codes: codes}
+}
+
+func escapeHTML(text string) string {
+	text = strings.ReplaceAll(text, "&", "&amp;")
+	text = strings.ReplaceAll(text, "<", "&lt;")
+	text = strings.ReplaceAll(text, ">", "&gt;")
+	return text
+}
diff --git a/pkg/channels/telegram/telegram_commands.go b/pkg/channels/telegram/telegram_commands.go
new file mode 100644
index 000000000..4bf1b3aff
--- /dev/null
+++ b/pkg/channels/telegram/telegram_commands.go
@@ -0,0 +1,153 @@
+package telegram
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/mymmrac/telego"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+type TelegramCommander interface {
+	Help(ctx context.Context, message telego.Message) error
+	Start(ctx context.Context, message telego.Message) error
+	Show(ctx context.Context, message telego.Message) error
+	List(ctx context.Context, message telego.Message) error
+}
+
+type cmd struct {
+	bot    *telego.Bot
+	config *config.Config
+}
+
+func NewTelegramCommands(bot *telego.Bot, cfg *config.Config) TelegramCommander {
+	return &cmd{
+		bot:    bot,
+		config: cfg,
+	}
+}
+
+func commandArgs(text string) string {
+	parts := strings.SplitN(text, " ", 2)
+	if len(parts) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(parts[1])
+}
+func (c *cmd) Help(ctx context.Context, message telego.Message) error {
+	msg := `/start - Start the bot
+/help - Show this help message
+/show [model|channel] - Show current configuration
+/list [models|channels] - List available options
+	`
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   msg,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+
+func (c *cmd) Start(ctx context.Context, message telego.Message) error {
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   "Hello! I am PicoClaw 🦞",
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+
+func (c *cmd) Show(ctx context.Context, message telego.Message) error {
+	args := commandArgs(message.Text)
+	if args == "" {
+		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+			ChatID: telego.ChatID{ID: message.Chat.ID},
+			Text:   "Usage: /show [model|channel]",
+			ReplyParameters: &telego.ReplyParameters{
+				MessageID: message.MessageID,
+			},
+		})
+		return err
+	}
+
+	var response string
+	switch args {
+	case "model":
+		response = fmt.Sprintf("Current Model: %s (Provider: %s)",
+			c.config.Agents.Defaults.Model,
+			c.config.Agents.Defaults.Provider)
+	case "channel":
+		response = "Current Channel: telegram"
+	default:
+		response = fmt.Sprintf("Unknown parameter: %s. Try 'model' or 'channel'.", args)
+	}
+
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   response,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+func (c *cmd) List(ctx context.Context, message telego.Message) error {
+	args := commandArgs(message.Text)
+	if args == "" {
+		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+			ChatID: telego.ChatID{ID: message.Chat.ID},
+			Text:   "Usage: /list [models|channels]",
+			ReplyParameters: &telego.ReplyParameters{
+				MessageID: message.MessageID,
+			},
+		})
+		return err
+	}
+
+	var response string
+	switch args {
+	case "models":
+		provider := c.config.Agents.Defaults.Provider
+		if provider == "" {
+			provider = "configured default"
+		}
+		response = fmt.Sprintf("Configured Model: %s\nProvider: %s\n\nTo change models, update config.yaml",
+			c.config.Agents.Defaults.Model, provider)
+
+	case "channels":
+		var enabled []string
+		if c.config.Channels.Telegram.Enabled {
+			enabled = append(enabled, "telegram")
+		}
+		if c.config.Channels.WhatsApp.Enabled {
+			enabled = append(enabled, "whatsapp")
+		}
+		if c.config.Channels.Feishu.Enabled {
+			enabled = append(enabled, "feishu")
+		}
+		if c.config.Channels.Discord.Enabled {
+			enabled = append(enabled, "discord")
+		}
+		if c.config.Channels.Slack.Enabled {
+			enabled = append(enabled, "slack")
+		}
+		response = fmt.Sprintf("Enabled Channels:\n- %s", strings.Join(enabled, "\n- "))
+
+	default:
+		response = fmt.Sprintf("Unknown parameter: %s. Try 'models' or 'channels'.", args)
+	}
+
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   response,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
new file mode 100644
index 000000000..85c017958
--- /dev/null
+++ b/pkg/channels/wecom/app.go
@@ -0,0 +1,636 @@
+package wecom
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+const (
+	wecomAPIBase = "https://qyapi.weixin.qq.com"
+)
+
+// WeComAppChannel implements the Channel interface for WeCom App (企业微信自建应用)
+type WeComAppChannel struct {
+	*channels.BaseChannel
+	config        config.WeComAppConfig
+	server        *http.Server
+	accessToken   string
+	tokenExpiry   time.Time
+	tokenMu       sync.RWMutex
+	ctx           context.Context
+	cancel        context.CancelFunc
+	processedMsgs map[string]bool // Message deduplication: msg_id -> processed
+	msgMu         sync.RWMutex
+}
+
+// WeComXMLMessage represents the XML message structure from WeCom
+type WeComXMLMessage struct {
+	XMLName      xml.Name `xml:"xml"`
+	ToUserName   string   `xml:"ToUserName"`
+	FromUserName string   `xml:"FromUserName"`
+	CreateTime   int64    `xml:"CreateTime"`
+	MsgType      string   `xml:"MsgType"`
+	Content      string   `xml:"Content"`
+	MsgId        int64    `xml:"MsgId"`
+	AgentID      int64    `xml:"AgentID"`
+	PicUrl       string   `xml:"PicUrl"`
+	MediaId      string   `xml:"MediaId"`
+	Format       string   `xml:"Format"`
+	ThumbMediaId string   `xml:"ThumbMediaId"`
+	LocationX    float64  `xml:"Location_X"`
+	LocationY    float64  `xml:"Location_Y"`
+	Scale        int      `xml:"Scale"`
+	Label        string   `xml:"Label"`
+	Title        string   `xml:"Title"`
+	Description  string   `xml:"Description"`
+	Url          string   `xml:"Url"`
+	Event        string   `xml:"Event"`
+	EventKey     string   `xml:"EventKey"`
+}
+
+// WeComTextMessage represents text message for sending
+type WeComTextMessage struct {
+	ToUser  string `json:"touser"`
+	MsgType string `json:"msgtype"`
+	AgentID int64  `json:"agentid"`
+	Text    struct {
+		Content string `json:"content"`
+	} `json:"text"`
+	Safe int `json:"safe,omitempty"`
+}
+
+// WeComMarkdownMessage represents markdown message for sending
+type WeComMarkdownMessage struct {
+	ToUser   string `json:"touser"`
+	MsgType  string `json:"msgtype"`
+	AgentID  int64  `json:"agentid"`
+	Markdown struct {
+		Content string `json:"content"`
+	} `json:"markdown"`
+}
+
+// WeComImageMessage represents image message for sending
+type WeComImageMessage struct {
+	ToUser  string `json:"touser"`
+	MsgType string `json:"msgtype"`
+	AgentID int64  `json:"agentid"`
+	Image   struct {
+		MediaID string `json:"media_id"`
+	} `json:"image"`
+}
+
+// WeComAccessTokenResponse represents the access token API response
+type WeComAccessTokenResponse struct {
+	ErrCode     int    `json:"errcode"`
+	ErrMsg      string `json:"errmsg"`
+	AccessToken string `json:"access_token"`
+	ExpiresIn   int    `json:"expires_in"`
+}
+
+// WeComSendMessageResponse represents the send message API response
+type WeComSendMessageResponse struct {
+	ErrCode      int    `json:"errcode"`
+	ErrMsg       string `json:"errmsg"`
+	InvalidUser  string `json:"invaliduser"`
+	InvalidParty string `json:"invalidparty"`
+	InvalidTag   string `json:"invalidtag"`
+}
+
+// PKCS7Padding adds PKCS7 padding
+type PKCS7Padding struct{}
+
+// NewWeComAppChannel creates a new WeCom App channel instance
+func NewWeComAppChannel(cfg config.WeComAppConfig, messageBus *bus.MessageBus) (*WeComAppChannel, error) {
+	if cfg.CorpID == "" || cfg.CorpSecret == "" || cfg.AgentID == 0 {
+		return nil, fmt.Errorf("wecom_app corp_id, corp_secret and agent_id are required")
+	}
+
+	base := channels.NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom)
+
+	return &WeComAppChannel{
+		BaseChannel:   base,
+		config:        cfg,
+		processedMsgs: make(map[string]bool),
+	}, nil
+}
+
+// Name returns the channel name
+func (c *WeComAppChannel) Name() string {
+	return "wecom_app"
+}
+
+// Start initializes the WeCom App channel with HTTP webhook server
+func (c *WeComAppChannel) Start(ctx context.Context) error {
+	logger.InfoC("wecom_app", "Starting WeCom App channel...")
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	// Get initial access token
+	if err := c.refreshAccessToken(); err != nil {
+		logger.WarnCF("wecom_app", "Failed to get initial access token", map[string]interface{}{
+			"error": err.Error(),
+		})
+	}
+
+	// Start token refresh goroutine
+	go c.tokenRefreshLoop()
+
+	// Setup HTTP server for webhook
+	mux := http.NewServeMux()
+	webhookPath := c.config.WebhookPath
+	if webhookPath == "" {
+		webhookPath = "/webhook/wecom-app"
+	}
+	mux.HandleFunc(webhookPath, c.handleWebhook)
+
+	// Health check endpoint
+	mux.HandleFunc("/health/wecom-app", c.handleHealth)
+
+	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
+	c.server = &http.Server{
+		Addr:    addr,
+		Handler: mux,
+	}
+
+	c.SetRunning(true)
+	logger.InfoCF("wecom_app", "WeCom App channel started", map[string]interface{}{
+		"address": addr,
+		"path":    webhookPath,
+	})
+
+	// Start server in goroutine
+	go func() {
+		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.ErrorCF("wecom_app", "HTTP server error", map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+	}()
+
+	return nil
+}
+
+// Stop gracefully stops the WeCom App channel
+func (c *WeComAppChannel) Stop(ctx context.Context) error {
+	logger.InfoC("wecom_app", "Stopping WeCom App channel...")
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	if c.server != nil {
+		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+		c.server.Shutdown(shutdownCtx)
+	}
+
+	c.SetRunning(false)
+	logger.InfoC("wecom_app", "WeCom App channel stopped")
+	return nil
+}
+
+// Send sends a message to WeCom user proactively using access token
+func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("wecom_app channel not running")
+	}
+
+	accessToken := c.getAccessToken()
+	if accessToken == "" {
+		return fmt.Errorf("no valid access token available")
+	}
+
+	logger.DebugCF("wecom_app", "Sending message", map[string]interface{}{
+		"chat_id": msg.ChatID,
+		"preview": utils.Truncate(msg.Content, 100),
+	})
+
+	return c.sendTextMessage(ctx, accessToken, msg.ChatID, msg.Content)
+}
+
+// handleWebhook handles incoming webhook requests from WeCom
+func (c *WeComAppChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	// Log all incoming requests for debugging
+	logger.DebugCF("wecom_app", "Received webhook request", map[string]interface{}{
+		"method": r.Method,
+		"url":    r.URL.String(),
+		"path":   r.URL.Path,
+		"query":  r.URL.RawQuery,
+	})
+
+	if r.Method == http.MethodGet {
+		// Handle verification request
+		c.handleVerification(ctx, w, r)
+		return
+	}
+
+	if r.Method == http.MethodPost {
+		// Handle message callback
+		c.handleMessageCallback(ctx, w, r)
+		return
+	}
+
+	logger.WarnCF("wecom_app", "Method not allowed", map[string]interface{}{
+		"method": r.Method,
+	})
+	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+}
+
+// handleVerification handles the URL verification request from WeCom
+func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	msgSignature := query.Get("msg_signature")
+	timestamp := query.Get("timestamp")
+	nonce := query.Get("nonce")
+	echostr := query.Get("echostr")
+
+	logger.DebugCF("wecom_app", "Handling verification request", map[string]interface{}{
+		"msg_signature": msgSignature,
+		"timestamp":     timestamp,
+		"nonce":         nonce,
+		"echostr":       echostr,
+		"corp_id":       c.config.CorpID,
+	})
+
+	if msgSignature == "" || timestamp == "" || nonce == "" || echostr == "" {
+		logger.ErrorC("wecom_app", "Missing parameters in verification request")
+		http.Error(w, "Missing parameters", http.StatusBadRequest)
+		return
+	}
+
+	// Verify signature
+	if !verifySignature(c.config.Token, msgSignature, timestamp, nonce, echostr) {
+		logger.WarnCF("wecom_app", "Signature verification failed", map[string]interface{}{
+			"token":         c.config.Token,
+			"msg_signature": msgSignature,
+			"timestamp":     timestamp,
+			"nonce":         nonce,
+		})
+		http.Error(w, "Invalid signature", http.StatusForbidden)
+		return
+	}
+
+	logger.DebugC("wecom_app", "Signature verification passed")
+
+	// Decrypt echostr with CorpID verification
+	// For WeCom App (自建应用), receiveid should be corp_id
+	logger.DebugCF("wecom_app", "Attempting to decrypt echostr", map[string]interface{}{
+		"encoding_aes_key": c.config.EncodingAESKey,
+		"corp_id":          c.config.CorpID,
+	})
+	decryptedEchoStr, err := decryptMessageWithVerify(echostr, c.config.EncodingAESKey, c.config.CorpID)
+	if err != nil {
+		logger.ErrorCF("wecom_app", "Failed to decrypt echostr", map[string]interface{}{
+			"error":            err.Error(),
+			"encoding_aes_key": c.config.EncodingAESKey,
+			"corp_id":          c.config.CorpID,
+		})
+		http.Error(w, "Decryption failed", http.StatusInternalServerError)
+		return
+	}
+
+	logger.DebugCF("wecom_app", "Successfully decrypted echostr", map[string]interface{}{
+		"decrypted": decryptedEchoStr,
+	})
+
+	// Remove BOM and whitespace as per WeCom documentation
+	// The response must be plain text without quotes, BOM, or newlines
+	decryptedEchoStr = strings.TrimSpace(decryptedEchoStr)
+	decryptedEchoStr = strings.TrimPrefix(decryptedEchoStr, "\xef\xbb\xbf") // Remove UTF-8 BOM
+	w.Write([]byte(decryptedEchoStr))
+}
+
+// handleMessageCallback handles incoming messages from WeCom
+func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	msgSignature := query.Get("msg_signature")
+	timestamp := query.Get("timestamp")
+	nonce := query.Get("nonce")
+
+	if msgSignature == "" || timestamp == "" || nonce == "" {
+		http.Error(w, "Missing parameters", http.StatusBadRequest)
+		return
+	}
+
+	// Read request body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, "Failed to read body", http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	// Parse XML to get encrypted message
+	var encryptedMsg struct {
+		XMLName    xml.Name `xml:"xml"`
+		ToUserName string   `xml:"ToUserName"`
+		Encrypt    string   `xml:"Encrypt"`
+		AgentID    string   `xml:"AgentID"`
+	}
+
+	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
+		logger.ErrorCF("wecom_app", "Failed to parse XML", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Invalid XML", http.StatusBadRequest)
+		return
+	}
+
+	// Verify signature
+	if !verifySignature(c.config.Token, msgSignature, timestamp, nonce, encryptedMsg.Encrypt) {
+		logger.WarnC("wecom_app", "Message signature verification failed")
+		http.Error(w, "Invalid signature", http.StatusForbidden)
+		return
+	}
+
+	// Decrypt message with CorpID verification
+	// For WeCom App (自建应用), receiveid should be corp_id
+	decryptedMsg, err := decryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, c.config.CorpID)
+	if err != nil {
+		logger.ErrorCF("wecom_app", "Failed to decrypt message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Decryption failed", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse decrypted XML message
+	var msg WeComXMLMessage
+	if err := xml.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
+		logger.ErrorCF("wecom_app", "Failed to parse decrypted message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Invalid message format", http.StatusBadRequest)
+		return
+	}
+
+	// Process the message with context
+	go c.processMessage(ctx, msg)
+
+	// Return success response immediately
+	// WeCom App requires response within configured timeout (default 5 seconds)
+	w.Write([]byte("success"))
+}
+
+// processMessage processes the received message
+func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessage) {
+	// Skip non-text messages for now (can be extended)
+	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" {
+		logger.DebugCF("wecom_app", "Skipping non-supported message type", map[string]interface{}{
+			"msg_type": msg.MsgType,
+		})
+		return
+	}
+
+	// Message deduplication: Use msg_id to prevent duplicate processing
+	// As per WeCom documentation, use msg_id for deduplication
+	msgID := fmt.Sprintf("%d", msg.MsgId)
+	c.msgMu.Lock()
+	if c.processedMsgs[msgID] {
+		c.msgMu.Unlock()
+		logger.DebugCF("wecom_app", "Skipping duplicate message", map[string]interface{}{
+			"msg_id": msgID,
+		})
+		return
+	}
+	c.processedMsgs[msgID] = true
+	c.msgMu.Unlock()
+
+	// Clean up old messages periodically (keep last 1000)
+	if len(c.processedMsgs) > 1000 {
+		c.msgMu.Lock()
+		c.processedMsgs = make(map[string]bool)
+		c.msgMu.Unlock()
+	}
+
+	senderID := msg.FromUserName
+	chatID := senderID // WeCom App uses user ID as chat ID for direct messages
+
+	// Build metadata
+	// WeCom App only supports direct messages (private chat)
+	metadata := map[string]string{
+		"msg_type":    msg.MsgType,
+		"msg_id":      fmt.Sprintf("%d", msg.MsgId),
+		"agent_id":    fmt.Sprintf("%d", msg.AgentID),
+		"platform":    "wecom_app",
+		"media_id":    msg.MediaId,
+		"create_time": fmt.Sprintf("%d", msg.CreateTime),
+		"peer_kind":   "direct",
+		"peer_id":     senderID,
+	}
+
+	content := msg.Content
+
+	logger.DebugCF("wecom_app", "Received message", map[string]interface{}{
+		"sender_id": senderID,
+		"msg_type":  msg.MsgType,
+		"preview":   utils.Truncate(content, 50),
+	})
+
+	// Handle the message through the base channel
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+}
+
+// tokenRefreshLoop periodically refreshes the access token
+func (c *WeComAppChannel) tokenRefreshLoop() {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-ticker.C:
+			if err := c.refreshAccessToken(); err != nil {
+				logger.ErrorCF("wecom_app", "Failed to refresh access token", map[string]interface{}{
+					"error": err.Error(),
+				})
+			}
+		}
+	}
+}
+
+// refreshAccessToken gets a new access token from WeCom API
+func (c *WeComAppChannel) refreshAccessToken() error {
+	apiURL := fmt.Sprintf("%s/cgi-bin/gettoken?corpid=%s&corpsecret=%s",
+		wecomAPIBase, url.QueryEscape(c.config.CorpID), url.QueryEscape(c.config.CorpSecret))
+
+	resp, err := http.Get(apiURL)
+	if err != nil {
+		return fmt.Errorf("failed to request access token: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var tokenResp WeComAccessTokenResponse
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if tokenResp.ErrCode != 0 {
+		return fmt.Errorf("API error: %s (code: %d)", tokenResp.ErrMsg, tokenResp.ErrCode)
+	}
+
+	c.tokenMu.Lock()
+	c.accessToken = tokenResp.AccessToken
+	c.tokenExpiry = time.Now().Add(time.Duration(tokenResp.ExpiresIn-300) * time.Second) // Refresh 5 minutes early
+	c.tokenMu.Unlock()
+
+	logger.DebugC("wecom_app", "Access token refreshed successfully")
+	return nil
+}
+
+// getAccessToken returns the current valid access token
+func (c *WeComAppChannel) getAccessToken() string {
+	c.tokenMu.RLock()
+	defer c.tokenMu.RUnlock()
+
+	if time.Now().After(c.tokenExpiry) {
+		return ""
+	}
+
+	return c.accessToken
+}
+
+// sendTextMessage sends a text message to a user
+func (c *WeComAppChannel) sendTextMessage(ctx context.Context, accessToken, userID, content string) error {
+	apiURL := fmt.Sprintf("%s/cgi-bin/message/send?access_token=%s", wecomAPIBase, accessToken)
+
+	msg := WeComTextMessage{
+		ToUser:  userID,
+		MsgType: "text",
+		AgentID: c.config.AgentID,
+	}
+	msg.Text.Content = content
+
+	jsonData, err := json.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %w", err)
+	}
+
+	// Use configurable timeout (default 5 seconds)
+	timeout := c.config.ReplyTimeout
+	if timeout <= 0 {
+		timeout = 5
+	}
+
+	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, apiURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send message: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var sendResp WeComSendMessageResponse
+	if err := json.Unmarshal(body, &sendResp); err != nil {
+		return fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if sendResp.ErrCode != 0 {
+		return fmt.Errorf("API error: %s (code: %d)", sendResp.ErrMsg, sendResp.ErrCode)
+	}
+
+	return nil
+}
+
+// sendMarkdownMessage sends a markdown message to a user
+func (c *WeComAppChannel) sendMarkdownMessage(ctx context.Context, accessToken, userID, content string) error {
+	apiURL := fmt.Sprintf("%s/cgi-bin/message/send?access_token=%s", wecomAPIBase, accessToken)
+
+	msg := WeComMarkdownMessage{
+		ToUser:  userID,
+		MsgType: "markdown",
+		AgentID: c.config.AgentID,
+	}
+	msg.Markdown.Content = content
+
+	jsonData, err := json.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %w", err)
+	}
+
+	// Use configurable timeout (default 5 seconds)
+	timeout := c.config.ReplyTimeout
+	if timeout <= 0 {
+		timeout = 5
+	}
+
+	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, apiURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send message: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var sendResp WeComSendMessageResponse
+	if err := json.Unmarshal(body, &sendResp); err != nil {
+		return fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if sendResp.ErrCode != 0 {
+		return fmt.Errorf("API error: %s (code: %d)", sendResp.ErrMsg, sendResp.ErrCode)
+	}
+
+	return nil
+}
+
+// handleHealth handles health check requests
+func (c *WeComAppChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
+	status := map[string]interface{}{
+		"status":    "ok",
+		"running":   c.IsRunning(),
+		"has_token": c.getAccessToken() != "",
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(status)
+}
diff --git a/pkg/channels/wecom/app_test.go b/pkg/channels/wecom/app_test.go
new file mode 100644
index 000000000..d9817fd49
--- /dev/null
+++ b/pkg/channels/wecom/app_test.go
@@ -0,0 +1,1086 @@
+package wecom
+
+import (
+	"bytes"
+	"context"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+// generateTestAESKeyApp generates a valid test AES key for WeCom App
+func generateTestAESKeyApp() string {
+	// AES key needs to be 32 bytes (256 bits) for AES-256
+	key := make([]byte, 32)
+	for i := range key {
+		key[i] = byte(i + 1)
+	}
+	// Return base64 encoded key without padding
+	return base64.StdEncoding.EncodeToString(key)[:43]
+}
+
+// encryptTestMessageApp encrypts a message for testing WeCom App
+func encryptTestMessageApp(message, aesKey string) (string, error) {
+	// Decode AES key
+	key, err := base64.StdEncoding.DecodeString(aesKey + "=")
+	if err != nil {
+		return "", err
+	}
+
+	// Prepare message: random(16) + msg_len(4) + msg + corp_id
+	random := make([]byte, 0, 16)
+	for i := 0; i < 16; i++ {
+		random = append(random, byte(i+1))
+	}
+
+	msgBytes := []byte(message)
+	corpID := []byte("test_corp_id")
+
+	msgLen := uint32(len(msgBytes))
+	lenBytes := make([]byte, 4)
+	binary.BigEndian.PutUint32(lenBytes, msgLen)
+
+	plainText := append(random, lenBytes...)
+	plainText = append(plainText, msgBytes...)
+	plainText = append(plainText, corpID...)
+
+	// PKCS7 padding
+	blockSize := aes.BlockSize
+	padding := blockSize - len(plainText)%blockSize
+	padText := bytes.Repeat([]byte{byte(padding)}, padding)
+	plainText = append(plainText, padText...)
+
+	// Encrypt
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	mode := cipher.NewCBCEncrypter(block, key[:aes.BlockSize])
+	cipherText := make([]byte, len(plainText))
+	mode.CryptBlocks(cipherText, plainText)
+
+	return base64.StdEncoding.EncodeToString(cipherText), nil
+}
+
+// generateSignatureApp generates a signature for testing WeCom App
+func generateSignatureApp(token, timestamp, nonce, msgEncrypt string) string {
+	params := []string{token, timestamp, nonce, msgEncrypt}
+	sort.Strings(params)
+	str := strings.Join(params, "")
+	hash := sha1.Sum([]byte(str))
+	return fmt.Sprintf("%x", hash)
+}
+
+func TestNewWeComAppChannel(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("missing corp_id", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "",
+			CorpSecret: "test_secret",
+			AgentID:    1000002,
+		}
+		_, err := NewWeComAppChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing corp_id, got nil")
+		}
+	})
+
+	t.Run("missing corp_secret", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "",
+			AgentID:    1000002,
+		}
+		_, err := NewWeComAppChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing corp_secret, got nil")
+		}
+	})
+
+	t.Run("missing agent_id", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "test_secret",
+			AgentID:    0,
+		}
+		_, err := NewWeComAppChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing agent_id, got nil")
+		}
+	})
+
+	t.Run("valid config", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "test_secret",
+			AgentID:    1000002,
+			AllowFrom:  []string{"user1", "user2"},
+		}
+		ch, err := NewWeComAppChannel(cfg, msgBus)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if ch.Name() != "wecom_app" {
+			t.Errorf("Name() = %q, want %q", ch.Name(), "wecom_app")
+		}
+		if ch.IsRunning() {
+			t.Error("new channel should not be running")
+		}
+	})
+}
+
+func TestWeComAppChannelIsAllowed(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("empty allowlist allows all", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "test_secret",
+			AgentID:    1000002,
+			AllowFrom:  []string{},
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+		if !ch.IsAllowed("any_user") {
+			t.Error("empty allowlist should allow all users")
+		}
+	})
+
+	t.Run("allowlist restricts users", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "test_secret",
+			AgentID:    1000002,
+			AllowFrom:  []string{"allowed_user"},
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+		if !ch.IsAllowed("allowed_user") {
+			t.Error("allowed user should pass allowlist check")
+		}
+		if ch.IsAllowed("blocked_user") {
+			t.Error("non-allowed user should be blocked")
+		}
+	})
+}
+
+func TestWeComAppVerifySignature(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComAppConfig{
+		CorpID:     "test_corp_id",
+		CorpSecret: "test_secret",
+		AgentID:    1000002,
+		Token:      "test_token",
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("valid signature", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		msgEncrypt := "test_message"
+		expectedSig := generateSignatureApp("test_token", timestamp, nonce, msgEncrypt)
+
+		if !verifySignature(ch.config.Token, expectedSig, timestamp, nonce, msgEncrypt) {
+			t.Error("valid signature should pass verification")
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		msgEncrypt := "test_message"
+
+		if verifySignature(ch.config.Token, "invalid_sig", timestamp, nonce, msgEncrypt) {
+			t.Error("invalid signature should fail verification")
+		}
+	})
+
+	t.Run("empty token skips verification", func(t *testing.T) {
+		cfgEmpty := config.WeComAppConfig{
+			CorpID:     "test_corp_id",
+			CorpSecret: "test_secret",
+			AgentID:    1000002,
+			Token:      "",
+		}
+		chEmpty, _ := NewWeComAppChannel(cfgEmpty, msgBus)
+
+		if !verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
+			t.Error("empty token should skip verification and return true")
+		}
+	})
+}
+
+func TestWeComAppDecryptMessage(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("decrypt without AES key", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:         "test_corp_id",
+			CorpSecret:     "test_secret",
+			AgentID:        1000002,
+			EncodingAESKey: "",
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+		// Without AES key, message should be base64 decoded only
+		plainText := "hello world"
+		encoded := base64.StdEncoding.EncodeToString([]byte(plainText))
+
+		result, err := decryptMessage(encoded, ch.config.EncodingAESKey)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != plainText {
+			t.Errorf("decryptMessage() = %q, want %q", result, plainText)
+		}
+	})
+
+	t.Run("decrypt with AES key", func(t *testing.T) {
+		aesKey := generateTestAESKeyApp()
+		cfg := config.WeComAppConfig{
+			CorpID:         "test_corp_id",
+			CorpSecret:     "test_secret",
+			AgentID:        1000002,
+			EncodingAESKey: aesKey,
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+		originalMsg := "<xml><Content>Hello</Content></xml>"
+		encrypted, err := encryptTestMessageApp(originalMsg, aesKey)
+		if err != nil {
+			t.Fatalf("failed to encrypt test message: %v", err)
+		}
+
+		result, err := decryptMessage(encrypted, ch.config.EncodingAESKey)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != originalMsg {
+			t.Errorf("WeComDecryptMessage() = %q, want %q", result, originalMsg)
+		}
+	})
+
+	t.Run("invalid base64", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:         "test_corp_id",
+			CorpSecret:     "test_secret",
+			AgentID:        1000002,
+			EncodingAESKey: "",
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+		_, err := decryptMessage("invalid_base64!!!", ch.config.EncodingAESKey)
+		if err == nil {
+			t.Error("expected error for invalid base64, got nil")
+		}
+	})
+
+	t.Run("invalid AES key", func(t *testing.T) {
+		cfg := config.WeComAppConfig{
+			CorpID:         "test_corp_id",
+			CorpSecret:     "test_secret",
+			AgentID:        1000002,
+			EncodingAESKey: "invalid_key",
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+		_, err := decryptMessage(base64.StdEncoding.EncodeToString([]byte("test")), ch.config.EncodingAESKey)
+		if err == nil {
+			t.Error("expected error for invalid AES key, got nil")
+		}
+	})
+
+	t.Run("ciphertext too short", func(t *testing.T) {
+		aesKey := generateTestAESKeyApp()
+		cfg := config.WeComAppConfig{
+			CorpID:         "test_corp_id",
+			CorpSecret:     "test_secret",
+			AgentID:        1000002,
+			EncodingAESKey: aesKey,
+		}
+		ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+		// Encrypt a very short message that results in ciphertext less than block size
+		shortData := make([]byte, 8)
+		_, err := decryptMessage(base64.StdEncoding.EncodeToString(shortData), ch.config.EncodingAESKey)
+		if err == nil {
+			t.Error("expected error for short ciphertext, got nil")
+		}
+	})
+}
+
+func TestWeComAppPKCS7Unpad(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{
+			name:     "empty input",
+			input:    []byte{},
+			expected: []byte{},
+		},
+		{
+			name:     "valid padding 3 bytes",
+			input:    append([]byte("hello"), bytes.Repeat([]byte{3}, 3)...),
+			expected: []byte("hello"),
+		},
+		{
+			name:     "valid padding 16 bytes (full block)",
+			input:    append([]byte("123456789012345"), bytes.Repeat([]byte{16}, 16)...),
+			expected: []byte("123456789012345"),
+		},
+		{
+			name:     "invalid padding larger than data",
+			input:    []byte{20},
+			expected: nil, // should return error
+		},
+		{
+			name:     "invalid padding zero",
+			input:    append([]byte("test"), byte(0)),
+			expected: nil, // should return error
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := pkcs7Unpad(tt.input)
+			if tt.expected == nil {
+				// This case should return an error
+				if err == nil {
+					t.Errorf("pkcs7Unpad() expected error for invalid padding, got result: %v", result)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("pkcs7Unpad() unexpected error: %v", err)
+				return
+			}
+			if !bytes.Equal(result, tt.expected) {
+				t.Errorf("pkcs7Unpad() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestWeComAppHandleVerification(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	aesKey := generateTestAESKeyApp()
+	cfg := config.WeComAppConfig{
+		CorpID:         "test_corp_id",
+		CorpSecret:     "test_secret",
+		AgentID:        1000002,
+		Token:          "test_token",
+		EncodingAESKey: aesKey,
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("valid verification request", func(t *testing.T) {
+		echostr := "test_echostr_123"
+		encryptedEchostr, _ := encryptTestMessageApp(echostr, aesKey)
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedEchostr)
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+		if w.Body.String() != echostr {
+			t.Errorf("response body = %q, want %q", w.Body.String(), echostr)
+		}
+	})
+
+	t.Run("missing parameters", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature=sig&timestamp=ts", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		echostr := "test_echostr"
+		encryptedEchostr, _ := encryptTestMessageApp(echostr, aesKey)
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusForbidden {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
+		}
+	})
+}
+
+func TestWeComAppHandleMessageCallback(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	aesKey := generateTestAESKeyApp()
+	cfg := config.WeComAppConfig{
+		CorpID:         "test_corp_id",
+		CorpSecret:     "test_secret",
+		AgentID:        1000002,
+		Token:          "test_token",
+		EncodingAESKey: aesKey,
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("valid message callback", func(t *testing.T) {
+		// Create XML message
+		xmlMsg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "text",
+			Content:      "Hello World",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+		xmlData, _ := xml.Marshal(xmlMsg)
+
+		// Encrypt message
+		encrypted, _ := encryptTestMessageApp(string(xmlData), aesKey)
+
+		// Create encrypted XML wrapper
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: encrypted,
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignatureApp("test_token", timestamp, nonce, encrypted)
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+		if w.Body.String() != "success" {
+			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
+		}
+	})
+
+	t.Run("missing parameters", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature=sig", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid XML", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignatureApp("test_token", timestamp, nonce, "")
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, strings.NewReader("invalid xml"))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: "encrypted_data",
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusForbidden {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
+		}
+	})
+}
+
+func TestWeComAppProcessMessage(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComAppConfig{
+		CorpID:     "test_corp_id",
+		CorpSecret: "test_secret",
+		AgentID:    1000002,
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("process text message", func(t *testing.T) {
+		msg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "text",
+			Content:      "Hello World",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("process image message", func(t *testing.T) {
+		msg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "image",
+			PicUrl:       "https://example.com/image.jpg",
+			MediaId:      "media_123",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("process voice message", func(t *testing.T) {
+		msg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "voice",
+			MediaId:      "media_123",
+			Format:       "amr",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("skip unsupported message type", func(t *testing.T) {
+		msg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "video",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("process event message", func(t *testing.T) {
+		msg := WeComXMLMessage{
+			ToUserName:   "corp_id",
+			FromUserName: "user123",
+			CreateTime:   1234567890,
+			MsgType:      "event",
+			Event:        "subscribe",
+			MsgId:        123456,
+			AgentID:      1000002,
+		}
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+}
+
+func TestWeComAppHandleWebhook(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComAppConfig{
+		CorpID:     "test_corp_id",
+		CorpSecret: "test_secret",
+		AgentID:    1000002,
+		Token:      "test_token",
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("GET request calls verification", func(t *testing.T) {
+		echostr := "test_echostr"
+		encoded := base64.StdEncoding.EncodeToString([]byte(echostr))
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignatureApp("test_token", timestamp, nonce, encoded)
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+	})
+
+	t.Run("POST request calls message callback", func(t *testing.T) {
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: base64.StdEncoding.EncodeToString([]byte("test")),
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		// Should not be method not allowed
+		if w.Code == http.StatusMethodNotAllowed {
+			t.Error("POST request should not return Method Not Allowed")
+		}
+	})
+
+	t.Run("unsupported method", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPut, "/webhook/wecom-app", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		if w.Code != http.StatusMethodNotAllowed {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusMethodNotAllowed)
+		}
+	})
+}
+
+func TestWeComAppHandleHealth(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComAppConfig{
+		CorpID:     "test_corp_id",
+		CorpSecret: "test_secret",
+		AgentID:    1000002,
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	req := httptest.NewRequest(http.MethodGet, "/health/wecom-app", nil)
+	w := httptest.NewRecorder()
+
+	ch.handleHealth(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+	}
+
+	contentType := w.Header().Get("Content-Type")
+	if contentType != "application/json" {
+		t.Errorf("Content-Type = %q, want %q", contentType, "application/json")
+	}
+
+	body := w.Body.String()
+	if !strings.Contains(body, "status") || !strings.Contains(body, "running") || !strings.Contains(body, "has_token") {
+		t.Errorf("response body should contain status, running, and has_token fields, got: %s", body)
+	}
+}
+
+func TestWeComAppAccessToken(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComAppConfig{
+		CorpID:     "test_corp_id",
+		CorpSecret: "test_secret",
+		AgentID:    1000002,
+	}
+	ch, _ := NewWeComAppChannel(cfg, msgBus)
+
+	t.Run("get empty access token initially", func(t *testing.T) {
+		token := ch.getAccessToken()
+		if token != "" {
+			t.Errorf("getAccessToken() = %q, want empty string", token)
+		}
+	})
+
+	t.Run("set and get access token", func(t *testing.T) {
+		ch.tokenMu.Lock()
+		ch.accessToken = "test_token_123"
+		ch.tokenExpiry = time.Now().Add(1 * time.Hour)
+		ch.tokenMu.Unlock()
+
+		token := ch.getAccessToken()
+		if token != "test_token_123" {
+			t.Errorf("getAccessToken() = %q, want %q", token, "test_token_123")
+		}
+	})
+
+	t.Run("expired token returns empty", func(t *testing.T) {
+		ch.tokenMu.Lock()
+		ch.accessToken = "expired_token"
+		ch.tokenExpiry = time.Now().Add(-1 * time.Hour)
+		ch.tokenMu.Unlock()
+
+		token := ch.getAccessToken()
+		if token != "" {
+			t.Errorf("getAccessToken() = %q, want empty string for expired token", token)
+		}
+	})
+}
+
+func TestWeComAppMessageStructures(t *testing.T) {
+	t.Run("WeComTextMessage structure", func(t *testing.T) {
+		msg := WeComTextMessage{
+			ToUser:  "user123",
+			MsgType: "text",
+			AgentID: 1000002,
+		}
+		msg.Text.Content = "Hello World"
+
+		if msg.ToUser != "user123" {
+			t.Errorf("ToUser = %q, want %q", msg.ToUser, "user123")
+		}
+		if msg.MsgType != "text" {
+			t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
+		}
+		if msg.AgentID != 1000002 {
+			t.Errorf("AgentID = %d, want %d", msg.AgentID, 1000002)
+		}
+		if msg.Text.Content != "Hello World" {
+			t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
+		}
+
+		// Test JSON marshaling
+		jsonData, err := json.Marshal(msg)
+		if err != nil {
+			t.Fatalf("failed to marshal JSON: %v", err)
+		}
+
+		var unmarshaled WeComTextMessage
+		err = json.Unmarshal(jsonData, &unmarshaled)
+		if err != nil {
+			t.Fatalf("failed to unmarshal JSON: %v", err)
+		}
+
+		if unmarshaled.ToUser != msg.ToUser {
+			t.Errorf("JSON round-trip failed for ToUser")
+		}
+	})
+
+	t.Run("WeComMarkdownMessage structure", func(t *testing.T) {
+		msg := WeComMarkdownMessage{
+			ToUser:  "user123",
+			MsgType: "markdown",
+			AgentID: 1000002,
+		}
+		msg.Markdown.Content = "# Hello\nWorld"
+
+		if msg.Markdown.Content != "# Hello\nWorld" {
+			t.Errorf("Markdown.Content = %q, want %q", msg.Markdown.Content, "# Hello\nWorld")
+		}
+
+		// Test JSON marshaling
+		jsonData, err := json.Marshal(msg)
+		if err != nil {
+			t.Fatalf("failed to marshal JSON: %v", err)
+		}
+
+		if !bytes.Contains(jsonData, []byte("markdown")) {
+			t.Error("JSON should contain 'markdown' field")
+		}
+	})
+
+	t.Run("WeComImageMessage structure", func(t *testing.T) {
+		msg := WeComImageMessage{
+			ToUser:  "user123",
+			MsgType: "image",
+			AgentID: 1000002,
+		}
+		msg.Image.MediaID = "media_123456"
+
+		if msg.Image.MediaID != "media_123456" {
+			t.Errorf("Image.MediaID = %q, want %q", msg.Image.MediaID, "media_123456")
+		}
+	})
+
+	t.Run("WeComAccessTokenResponse structure", func(t *testing.T) {
+		jsonData := `{
+				"errcode": 0,
+				"errmsg": "ok",
+				"access_token": "test_access_token",
+				"expires_in": 7200
+			}`
+
+		var resp WeComAccessTokenResponse
+		err := json.Unmarshal([]byte(jsonData), &resp)
+		if err != nil {
+			t.Fatalf("failed to unmarshal JSON: %v", err)
+		}
+
+		if resp.ErrCode != 0 {
+			t.Errorf("ErrCode = %d, want %d", resp.ErrCode, 0)
+		}
+		if resp.ErrMsg != "ok" {
+			t.Errorf("ErrMsg = %q, want %q", resp.ErrMsg, "ok")
+		}
+		if resp.AccessToken != "test_access_token" {
+			t.Errorf("AccessToken = %q, want %q", resp.AccessToken, "test_access_token")
+		}
+		if resp.ExpiresIn != 7200 {
+			t.Errorf("ExpiresIn = %d, want %d", resp.ExpiresIn, 7200)
+		}
+	})
+
+	t.Run("WeComSendMessageResponse structure", func(t *testing.T) {
+		jsonData := `{
+				"errcode": 0,
+				"errmsg": "ok",
+				"invaliduser": "",
+				"invalidparty": "",
+				"invalidtag": ""
+			}`
+
+		var resp WeComSendMessageResponse
+		err := json.Unmarshal([]byte(jsonData), &resp)
+		if err != nil {
+			t.Fatalf("failed to unmarshal JSON: %v", err)
+		}
+
+		if resp.ErrCode != 0 {
+			t.Errorf("ErrCode = %d, want %d", resp.ErrCode, 0)
+		}
+		if resp.ErrMsg != "ok" {
+			t.Errorf("ErrMsg = %q, want %q", resp.ErrMsg, "ok")
+		}
+	})
+}
+
+func TestWeComAppXMLMessageStructure(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[text]]></MsgType>
+	<Content><![CDATA[Hello World]]></Content>
+	<MsgId>1234567890123456</MsgId>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.ToUserName != "corp_id" {
+		t.Errorf("ToUserName = %q, want %q", msg.ToUserName, "corp_id")
+	}
+	if msg.FromUserName != "user123" {
+		t.Errorf("FromUserName = %q, want %q", msg.FromUserName, "user123")
+	}
+	if msg.CreateTime != 1234567890 {
+		t.Errorf("CreateTime = %d, want %d", msg.CreateTime, 1234567890)
+	}
+	if msg.MsgType != "text" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
+	}
+	if msg.Content != "Hello World" {
+		t.Errorf("Content = %q, want %q", msg.Content, "Hello World")
+	}
+	if msg.MsgId != 1234567890123456 {
+		t.Errorf("MsgId = %d, want %d", msg.MsgId, 1234567890123456)
+	}
+	if msg.AgentID != 1000002 {
+		t.Errorf("AgentID = %d, want %d", msg.AgentID, 1000002)
+	}
+}
+
+func TestWeComAppXMLMessageImage(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[image]]></MsgType>
+	<PicUrl><![CDATA[https://example.com/image.jpg]]></PicUrl>
+	<MediaId><![CDATA[media_123]]></MediaId>
+	<MsgId>1234567890123456</MsgId>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.MsgType != "image" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "image")
+	}
+	if msg.PicUrl != "https://example.com/image.jpg" {
+		t.Errorf("PicUrl = %q, want %q", msg.PicUrl, "https://example.com/image.jpg")
+	}
+	if msg.MediaId != "media_123" {
+		t.Errorf("MediaId = %q, want %q", msg.MediaId, "media_123")
+	}
+}
+
+func TestWeComAppXMLMessageVoice(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[voice]]></MsgType>
+	<MediaId><![CDATA[media_123]]></MediaId>
+	<Format><![CDATA[amr]]></Format>
+	<MsgId>1234567890123456</MsgId>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.MsgType != "voice" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "voice")
+	}
+	if msg.Format != "amr" {
+		t.Errorf("Format = %q, want %q", msg.Format, "amr")
+	}
+}
+
+func TestWeComAppXMLMessageLocation(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[location]]></MsgType>
+	<Location_X>39.9042</Location_X>
+	<Location_Y>116.4074</Location_Y>
+	<Scale>16</Scale>
+	<Label><![CDATA[Beijing]]></Label>
+	<MsgId>1234567890123456</MsgId>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.MsgType != "location" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "location")
+	}
+	if msg.LocationX != 39.9042 {
+		t.Errorf("LocationX = %f, want %f", msg.LocationX, 39.9042)
+	}
+	if msg.LocationY != 116.4074 {
+		t.Errorf("LocationY = %f, want %f", msg.LocationY, 116.4074)
+	}
+	if msg.Scale != 16 {
+		t.Errorf("Scale = %d, want %d", msg.Scale, 16)
+	}
+	if msg.Label != "Beijing" {
+		t.Errorf("Label = %q, want %q", msg.Label, "Beijing")
+	}
+}
+
+func TestWeComAppXMLMessageLink(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[link]]></MsgType>
+	<Title><![CDATA[Link Title]]></Title>
+	<Description><![CDATA[Link Description]]></Description>
+	<Url><![CDATA[https://example.com]]></Url>
+	<MsgId>1234567890123456</MsgId>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.MsgType != "link" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "link")
+	}
+	if msg.Title != "Link Title" {
+		t.Errorf("Title = %q, want %q", msg.Title, "Link Title")
+	}
+	if msg.Description != "Link Description" {
+		t.Errorf("Description = %q, want %q", msg.Description, "Link Description")
+	}
+	if msg.Url != "https://example.com" {
+		t.Errorf("Url = %q, want %q", msg.Url, "https://example.com")
+	}
+}
+
+func TestWeComAppXMLMessageEvent(t *testing.T) {
+	xmlData := `<?xml version="1.0"?>
+<xml>
+	<ToUserName><![CDATA[corp_id]]></ToUserName>
+	<FromUserName><![CDATA[user123]]></FromUserName>
+	<CreateTime>1234567890</CreateTime>
+	<MsgType><![CDATA[event]]></MsgType>
+	<Event><![CDATA[subscribe]]></Event>
+	<EventKey><![CDATA[event_key_123]]></EventKey>
+	<AgentID>1000002</AgentID>
+</xml>`
+
+	var msg WeComXMLMessage
+	err := xml.Unmarshal([]byte(xmlData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal XML: %v", err)
+	}
+
+	if msg.MsgType != "event" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "event")
+	}
+	if msg.Event != "subscribe" {
+		t.Errorf("Event = %q, want %q", msg.Event, "subscribe")
+	}
+	if msg.EventKey != "event_key_123" {
+		t.Errorf("EventKey = %q, want %q", msg.EventKey, "event_key_123")
+	}
+}
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
new file mode 100644
index 000000000..9683a308f
--- /dev/null
+++ b/pkg/channels/wecom/bot.go
@@ -0,0 +1,469 @@
+package wecom
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+// WeComBotChannel implements the Channel interface for WeCom Bot (企业微信智能机器人)
+// Uses webhook callback mode - simpler than WeCom App but only supports passive replies
+type WeComBotChannel struct {
+	*channels.BaseChannel
+	config        config.WeComConfig
+	server        *http.Server
+	ctx           context.Context
+	cancel        context.CancelFunc
+	processedMsgs map[string]bool // Message deduplication: msg_id -> processed
+	msgMu         sync.RWMutex
+}
+
+// WeComBotMessage represents the JSON message structure from WeCom Bot (AIBOT)
+type WeComBotMessage struct {
+	MsgID    string `json:"msgid"`
+	AIBotID  string `json:"aibotid"`
+	ChatID   string `json:"chatid"`   // Session ID, only present for group chats
+	ChatType string `json:"chattype"` // "single" for DM, "group" for group chat
+	From     struct {
+		UserID string `json:"userid"`
+	} `json:"from"`
+	ResponseURL string `json:"response_url"`
+	MsgType     string `json:"msgtype"` // text, image, voice, file, mixed
+	Text        struct {
+		Content string `json:"content"`
+	} `json:"text"`
+	Image struct {
+		URL string `json:"url"`
+	} `json:"image"`
+	Voice struct {
+		Content string `json:"content"` // Voice to text content
+	} `json:"voice"`
+	File struct {
+		URL string `json:"url"`
+	} `json:"file"`
+	Mixed struct {
+		MsgItem []struct {
+			MsgType string `json:"msgtype"`
+			Text    struct {
+				Content string `json:"content"`
+			} `json:"text"`
+			Image struct {
+				URL string `json:"url"`
+			} `json:"image"`
+		} `json:"msg_item"`
+	} `json:"mixed"`
+	Quote struct {
+		MsgType string `json:"msgtype"`
+		Text    struct {
+			Content string `json:"content"`
+		} `json:"text"`
+	} `json:"quote"`
+}
+
+// WeComBotReplyMessage represents the reply message structure
+type WeComBotReplyMessage struct {
+	MsgType string `json:"msgtype"`
+	Text    struct {
+		Content string `json:"content"`
+	} `json:"text,omitempty"`
+}
+
+// NewWeComBotChannel creates a new WeCom Bot channel instance
+func NewWeComBotChannel(cfg config.WeComConfig, messageBus *bus.MessageBus) (*WeComBotChannel, error) {
+	if cfg.Token == "" || cfg.WebhookURL == "" {
+		return nil, fmt.Errorf("wecom token and webhook_url are required")
+	}
+
+	base := channels.NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom)
+
+	return &WeComBotChannel{
+		BaseChannel:   base,
+		config:        cfg,
+		processedMsgs: make(map[string]bool),
+	}, nil
+}
+
+// Name returns the channel name
+func (c *WeComBotChannel) Name() string {
+	return "wecom"
+}
+
+// Start initializes the WeCom Bot channel with HTTP webhook server
+func (c *WeComBotChannel) Start(ctx context.Context) error {
+	logger.InfoC("wecom", "Starting WeCom Bot channel...")
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	// Setup HTTP server for webhook
+	mux := http.NewServeMux()
+	webhookPath := c.config.WebhookPath
+	if webhookPath == "" {
+		webhookPath = "/webhook/wecom"
+	}
+	mux.HandleFunc(webhookPath, c.handleWebhook)
+
+	// Health check endpoint
+	mux.HandleFunc("/health/wecom", c.handleHealth)
+
+	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
+	c.server = &http.Server{
+		Addr:    addr,
+		Handler: mux,
+	}
+
+	c.SetRunning(true)
+	logger.InfoCF("wecom", "WeCom Bot channel started", map[string]interface{}{
+		"address": addr,
+		"path":    webhookPath,
+	})
+
+	// Start server in goroutine
+	go func() {
+		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.ErrorCF("wecom", "HTTP server error", map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+	}()
+
+	return nil
+}
+
+// Stop gracefully stops the WeCom Bot channel
+func (c *WeComBotChannel) Stop(ctx context.Context) error {
+	logger.InfoC("wecom", "Stopping WeCom Bot channel...")
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	if c.server != nil {
+		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+		c.server.Shutdown(shutdownCtx)
+	}
+
+	c.SetRunning(false)
+	logger.InfoC("wecom", "WeCom Bot channel stopped")
+	return nil
+}
+
+// Send sends a message to WeCom user via webhook API
+// Note: WeCom Bot can only reply within the configured timeout (default 5 seconds) of receiving a message
+// For delayed responses, we use the webhook URL
+func (c *WeComBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("wecom channel not running")
+	}
+
+	logger.DebugCF("wecom", "Sending message via webhook", map[string]interface{}{
+		"chat_id": msg.ChatID,
+		"preview": utils.Truncate(msg.Content, 100),
+	})
+
+	return c.sendWebhookReply(ctx, msg.ChatID, msg.Content)
+}
+
+// handleWebhook handles incoming webhook requests from WeCom
+func (c *WeComBotChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	if r.Method == http.MethodGet {
+		// Handle verification request
+		c.handleVerification(ctx, w, r)
+		return
+	}
+
+	if r.Method == http.MethodPost {
+		// Handle message callback
+		c.handleMessageCallback(ctx, w, r)
+		return
+	}
+
+	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+}
+
+// handleVerification handles the URL verification request from WeCom
+func (c *WeComBotChannel) handleVerification(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	msgSignature := query.Get("msg_signature")
+	timestamp := query.Get("timestamp")
+	nonce := query.Get("nonce")
+	echostr := query.Get("echostr")
+
+	if msgSignature == "" || timestamp == "" || nonce == "" || echostr == "" {
+		http.Error(w, "Missing parameters", http.StatusBadRequest)
+		return
+	}
+
+	// Verify signature
+	if !verifySignature(c.config.Token, msgSignature, timestamp, nonce, echostr) {
+		logger.WarnC("wecom", "Signature verification failed")
+		http.Error(w, "Invalid signature", http.StatusForbidden)
+		return
+	}
+
+	// Decrypt echostr
+	// For AIBOT (智能机器人), receiveid should be empty string ""
+	// Reference: https://developer.work.weixin.qq.com/document/path/101033
+	decryptedEchoStr, err := decryptMessageWithVerify(echostr, c.config.EncodingAESKey, "")
+	if err != nil {
+		logger.ErrorCF("wecom", "Failed to decrypt echostr", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Decryption failed", http.StatusInternalServerError)
+		return
+	}
+
+	// Remove BOM and whitespace as per WeCom documentation
+	// The response must be plain text without quotes, BOM, or newlines
+	decryptedEchoStr = strings.TrimSpace(decryptedEchoStr)
+	decryptedEchoStr = strings.TrimPrefix(decryptedEchoStr, "\xef\xbb\xbf") // Remove UTF-8 BOM
+	w.Write([]byte(decryptedEchoStr))
+}
+
+// handleMessageCallback handles incoming messages from WeCom
+func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	msgSignature := query.Get("msg_signature")
+	timestamp := query.Get("timestamp")
+	nonce := query.Get("nonce")
+
+	if msgSignature == "" || timestamp == "" || nonce == "" {
+		http.Error(w, "Missing parameters", http.StatusBadRequest)
+		return
+	}
+
+	// Read request body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, "Failed to read body", http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	// Parse XML to get encrypted message
+	var encryptedMsg struct {
+		XMLName    xml.Name `xml:"xml"`
+		ToUserName string   `xml:"ToUserName"`
+		Encrypt    string   `xml:"Encrypt"`
+		AgentID    string   `xml:"AgentID"`
+	}
+
+	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
+		logger.ErrorCF("wecom", "Failed to parse XML", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Invalid XML", http.StatusBadRequest)
+		return
+	}
+
+	// Verify signature
+	if !verifySignature(c.config.Token, msgSignature, timestamp, nonce, encryptedMsg.Encrypt) {
+		logger.WarnC("wecom", "Message signature verification failed")
+		http.Error(w, "Invalid signature", http.StatusForbidden)
+		return
+	}
+
+	// Decrypt message
+	// For AIBOT (智能机器人), receiveid should be empty string ""
+	// Reference: https://developer.work.weixin.qq.com/document/path/101033
+	decryptedMsg, err := decryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, "")
+	if err != nil {
+		logger.ErrorCF("wecom", "Failed to decrypt message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Decryption failed", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse decrypted JSON message (AIBOT uses JSON format)
+	var msg WeComBotMessage
+	if err := json.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
+		logger.ErrorCF("wecom", "Failed to parse decrypted message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		http.Error(w, "Invalid message format", http.StatusBadRequest)
+		return
+	}
+
+	// Process the message asynchronously with context
+	go c.processMessage(ctx, msg)
+
+	// Return success response immediately
+	// WeCom Bot requires response within configured timeout (default 5 seconds)
+	w.Write([]byte("success"))
+}
+
+// processMessage processes the received message
+func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessage) {
+	// Skip unsupported message types
+	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" && msg.MsgType != "file" && msg.MsgType != "mixed" {
+		logger.DebugCF("wecom", "Skipping non-supported message type", map[string]interface{}{
+			"msg_type": msg.MsgType,
+		})
+		return
+	}
+
+	// Message deduplication: Use msg_id to prevent duplicate processing
+	msgID := msg.MsgID
+	c.msgMu.Lock()
+	if c.processedMsgs[msgID] {
+		c.msgMu.Unlock()
+		logger.DebugCF("wecom", "Skipping duplicate message", map[string]interface{}{
+			"msg_id": msgID,
+		})
+		return
+	}
+	c.processedMsgs[msgID] = true
+	c.msgMu.Unlock()
+
+	// Clean up old messages periodically (keep last 1000)
+	if len(c.processedMsgs) > 1000 {
+		c.msgMu.Lock()
+		c.processedMsgs = make(map[string]bool)
+		c.msgMu.Unlock()
+	}
+
+	senderID := msg.From.UserID
+
+	// Determine if this is a group chat or direct message
+	// ChatType: "single" for DM, "group" for group chat
+	isGroupChat := msg.ChatType == "group"
+
+	var chatID, peerKind, peerID string
+	if isGroupChat {
+		// Group chat: use ChatID as chatID and peer_id
+		chatID = msg.ChatID
+		peerKind = "group"
+		peerID = msg.ChatID
+	} else {
+		// Direct message: use senderID as chatID and peer_id
+		chatID = senderID
+		peerKind = "direct"
+		peerID = senderID
+	}
+
+	// Extract content based on message type
+	var content string
+	switch msg.MsgType {
+	case "text":
+		content = msg.Text.Content
+	case "voice":
+		content = msg.Voice.Content // Voice to text content
+	case "mixed":
+		// For mixed messages, concatenate text items
+		for _, item := range msg.Mixed.MsgItem {
+			if item.MsgType == "text" {
+				content += item.Text.Content
+			}
+		}
+	case "image", "file":
+		// For image and file, we don't have text content
+		content = ""
+	}
+
+	// Build metadata
+	metadata := map[string]string{
+		"msg_type":     msg.MsgType,
+		"msg_id":       msg.MsgID,
+		"platform":     "wecom",
+		"peer_kind":    peerKind,
+		"peer_id":      peerID,
+		"response_url": msg.ResponseURL,
+	}
+	if isGroupChat {
+		metadata["chat_id"] = msg.ChatID
+		metadata["sender_id"] = senderID
+	}
+
+	logger.DebugCF("wecom", "Received message", map[string]interface{}{
+		"sender_id":     senderID,
+		"msg_type":      msg.MsgType,
+		"peer_kind":     peerKind,
+		"is_group_chat": isGroupChat,
+		"preview":       utils.Truncate(content, 50),
+	})
+
+	// Handle the message through the base channel
+	c.HandleMessage(senderID, chatID, content, nil, metadata)
+}
+
+// sendWebhookReply sends a reply using the webhook URL
+func (c *WeComBotChannel) sendWebhookReply(ctx context.Context, userID, content string) error {
+	reply := WeComBotReplyMessage{
+		MsgType: "text",
+	}
+	reply.Text.Content = content
+
+	jsonData, err := json.Marshal(reply)
+	if err != nil {
+		return fmt.Errorf("failed to marshal reply: %w", err)
+	}
+
+	// Use configurable timeout (default 5 seconds)
+	timeout := c.config.ReplyTimeout
+	if timeout <= 0 {
+		timeout = 5
+	}
+
+	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, c.config.WebhookURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send webhook reply: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	// Check response
+	var result struct {
+		ErrCode int    `json:"errcode"`
+		ErrMsg  string `json:"errmsg"`
+	}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if result.ErrCode != 0 {
+		return fmt.Errorf("webhook API error: %s (code: %d)", result.ErrMsg, result.ErrCode)
+	}
+
+	return nil
+}
+
+// handleHealth handles health check requests
+func (c *WeComBotChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
+	status := map[string]interface{}{
+		"status":  "ok",
+		"running": c.IsRunning(),
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(status)
+}
diff --git a/pkg/channels/wecom/bot_test.go b/pkg/channels/wecom/bot_test.go
new file mode 100644
index 000000000..460e0058f
--- /dev/null
+++ b/pkg/channels/wecom/bot_test.go
@@ -0,0 +1,753 @@
+package wecom
+
+import (
+	"bytes"
+	"context"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+// generateTestAESKey generates a valid test AES key
+func generateTestAESKey() string {
+	// AES key needs to be 32 bytes (256 bits) for AES-256
+	key := make([]byte, 32)
+	for i := range key {
+		key[i] = byte(i)
+	}
+	// Return base64 encoded key without padding
+	return base64.StdEncoding.EncodeToString(key)[:43]
+}
+
+// encryptTestMessage encrypts a message for testing (AIBOT JSON format)
+func encryptTestMessage(message, aesKey string) (string, error) {
+	// Decode AES key
+	key, err := base64.StdEncoding.DecodeString(aesKey + "=")
+	if err != nil {
+		return "", err
+	}
+
+	// Prepare message: random(16) + msg_len(4) + msg + receiveid
+	random := make([]byte, 0, 16)
+	for i := 0; i < 16; i++ {
+		random = append(random, byte(i))
+	}
+
+	msgBytes := []byte(message)
+	receiveID := []byte("test_aibot_id")
+
+	msgLen := uint32(len(msgBytes))
+	lenBytes := make([]byte, 4)
+	binary.BigEndian.PutUint32(lenBytes, msgLen)
+
+	plainText := append(random, lenBytes...)
+	plainText = append(plainText, msgBytes...)
+	plainText = append(plainText, receiveID...)
+
+	// PKCS7 padding
+	blockSize := aes.BlockSize
+	padding := blockSize - len(plainText)%blockSize
+	padText := bytes.Repeat([]byte{byte(padding)}, padding)
+	plainText = append(plainText, padText...)
+
+	// Encrypt
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	mode := cipher.NewCBCEncrypter(block, key[:aes.BlockSize])
+	cipherText := make([]byte, len(plainText))
+	mode.CryptBlocks(cipherText, plainText)
+
+	return base64.StdEncoding.EncodeToString(cipherText), nil
+}
+
+// generateSignature generates a signature for testing
+func generateSignature(token, timestamp, nonce, msgEncrypt string) string {
+	params := []string{token, timestamp, nonce, msgEncrypt}
+	sort.Strings(params)
+	str := strings.Join(params, "")
+	hash := sha1.Sum([]byte(str))
+	return fmt.Sprintf("%x", hash)
+}
+
+func TestNewWeComBotChannel(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("missing token", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:      "",
+			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+		}
+		_, err := NewWeComBotChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing token, got nil")
+		}
+	})
+
+	t.Run("missing webhook_url", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:      "test_token",
+			WebhookURL: "",
+		}
+		_, err := NewWeComBotChannel(cfg, msgBus)
+		if err == nil {
+			t.Error("expected error for missing webhook_url, got nil")
+		}
+	})
+
+	t.Run("valid config", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:      "test_token",
+			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			AllowFrom:  []string{"user1", "user2"},
+		}
+		ch, err := NewWeComBotChannel(cfg, msgBus)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if ch.Name() != "wecom" {
+			t.Errorf("Name() = %q, want %q", ch.Name(), "wecom")
+		}
+		if ch.IsRunning() {
+			t.Error("new channel should not be running")
+		}
+	})
+}
+
+func TestWeComBotChannelIsAllowed(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("empty allowlist allows all", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:      "test_token",
+			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			AllowFrom:  []string{},
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+		if !ch.IsAllowed("any_user") {
+			t.Error("empty allowlist should allow all users")
+		}
+	})
+
+	t.Run("allowlist restricts users", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:      "test_token",
+			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			AllowFrom:  []string{"allowed_user"},
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+		if !ch.IsAllowed("allowed_user") {
+			t.Error("allowed user should pass allowlist check")
+		}
+		if ch.IsAllowed("blocked_user") {
+			t.Error("non-allowed user should be blocked")
+		}
+	})
+}
+
+func TestWeComBotVerifySignature(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComConfig{
+		Token:      "test_token",
+		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	t.Run("valid signature", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		msgEncrypt := "test_message"
+		expectedSig := generateSignature("test_token", timestamp, nonce, msgEncrypt)
+
+		if !verifySignature(ch.config.Token, expectedSig, timestamp, nonce, msgEncrypt) {
+			t.Error("valid signature should pass verification")
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		msgEncrypt := "test_message"
+
+		if verifySignature(ch.config.Token, "invalid_sig", timestamp, nonce, msgEncrypt) {
+			t.Error("invalid signature should fail verification")
+		}
+	})
+
+	t.Run("empty token skips verification", func(t *testing.T) {
+		// Create a channel manually with empty token to test the behavior
+		cfgEmpty := config.WeComConfig{
+			Token:      "",
+			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+		}
+		base := channels.NewBaseChannel("wecom", cfgEmpty, msgBus, cfgEmpty.AllowFrom)
+		chEmpty := &WeComBotChannel{
+			BaseChannel: base,
+			config:      cfgEmpty,
+		}
+
+		if !verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
+			t.Error("empty token should skip verification and return true")
+		}
+	})
+}
+
+func TestWeComBotDecryptMessage(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+
+	t.Run("decrypt without AES key", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:          "test_token",
+			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			EncodingAESKey: "",
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+		// Without AES key, message should be base64 decoded only
+		plainText := "hello world"
+		encoded := base64.StdEncoding.EncodeToString([]byte(plainText))
+
+		result, err := decryptMessage(encoded, ch.config.EncodingAESKey)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != plainText {
+			t.Errorf("decryptMessage() = %q, want %q", result, plainText)
+		}
+	})
+
+	t.Run("decrypt with AES key", func(t *testing.T) {
+		aesKey := generateTestAESKey()
+		cfg := config.WeComConfig{
+			Token:          "test_token",
+			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			EncodingAESKey: aesKey,
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+		originalMsg := "<xml><Content>Hello</Content></xml>"
+		encrypted, err := encryptTestMessage(originalMsg, aesKey)
+		if err != nil {
+			t.Fatalf("failed to encrypt test message: %v", err)
+		}
+
+		result, err := decryptMessage(encrypted, ch.config.EncodingAESKey)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != originalMsg {
+			t.Errorf("WeComDecryptMessage() = %q, want %q", result, originalMsg)
+		}
+	})
+
+	t.Run("invalid base64", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:          "test_token",
+			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			EncodingAESKey: "",
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+		_, err := decryptMessage("invalid_base64!!!", ch.config.EncodingAESKey)
+		if err == nil {
+			t.Error("expected error for invalid base64, got nil")
+		}
+	})
+
+	t.Run("invalid AES key", func(t *testing.T) {
+		cfg := config.WeComConfig{
+			Token:          "test_token",
+			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			EncodingAESKey: "invalid_key",
+		}
+		ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+		_, err := decryptMessage(base64.StdEncoding.EncodeToString([]byte("test")), ch.config.EncodingAESKey)
+		if err == nil {
+			t.Error("expected error for invalid AES key, got nil")
+		}
+	})
+}
+
+func TestWeComBotPKCS7Unpad(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{
+			name:     "empty input",
+			input:    []byte{},
+			expected: []byte{},
+		},
+		{
+			name:     "valid padding 3 bytes",
+			input:    append([]byte("hello"), bytes.Repeat([]byte{3}, 3)...),
+			expected: []byte("hello"),
+		},
+		{
+			name:     "valid padding 16 bytes (full block)",
+			input:    append([]byte("123456789012345"), bytes.Repeat([]byte{16}, 16)...),
+			expected: []byte("123456789012345"),
+		},
+		{
+			name:     "invalid padding larger than data",
+			input:    []byte{20},
+			expected: nil, // should return error
+		},
+		{
+			name:     "invalid padding zero",
+			input:    append([]byte("test"), byte(0)),
+			expected: nil, // should return error
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := pkcs7Unpad(tt.input)
+			if tt.expected == nil {
+				// This case should return an error
+				if err == nil {
+					t.Errorf("pkcs7Unpad() expected error for invalid padding, got result: %v", result)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("pkcs7Unpad() unexpected error: %v", err)
+				return
+			}
+			if !bytes.Equal(result, tt.expected) {
+				t.Errorf("pkcs7Unpad() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestWeComBotHandleVerification(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	aesKey := generateTestAESKey()
+	cfg := config.WeComConfig{
+		Token:          "test_token",
+		EncodingAESKey: aesKey,
+		WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	t.Run("valid verification request", func(t *testing.T) {
+		echostr := "test_echostr_123"
+		encryptedEchostr, _ := encryptTestMessage(echostr, aesKey)
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, encryptedEchostr)
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+		if w.Body.String() != echostr {
+			t.Errorf("response body = %q, want %q", w.Body.String(), echostr)
+		}
+	})
+
+	t.Run("missing parameters", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature=sig&timestamp=ts", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		echostr := "test_echostr"
+		encryptedEchostr, _ := encryptTestMessage(echostr, aesKey)
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleVerification(context.Background(), w, req)
+
+		if w.Code != http.StatusForbidden {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
+		}
+	})
+}
+
+func TestWeComBotHandleMessageCallback(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	aesKey := generateTestAESKey()
+	cfg := config.WeComConfig{
+		Token:          "test_token",
+		EncodingAESKey: aesKey,
+		WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	t.Run("valid direct message callback", func(t *testing.T) {
+		// Create JSON message for direct chat (single)
+		jsonMsg := `{
+					"msgid": "test_msg_id_123",
+					"aibotid": "test_aibot_id",
+					"chattype": "single",
+					"from": {"userid": "user123"},
+					"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+					"msgtype": "text",
+					"text": {"content": "Hello World"}
+				}`
+
+		// Encrypt message
+		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
+
+		// Create encrypted XML wrapper
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: encrypted,
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, encrypted)
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+		if w.Body.String() != "success" {
+			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
+		}
+	})
+
+	t.Run("valid group message callback", func(t *testing.T) {
+		// Create JSON message for group chat
+		jsonMsg := `{
+					"msgid": "test_msg_id_456",
+					"aibotid": "test_aibot_id",
+					"chatid": "group_chat_id_123",
+					"chattype": "group",
+					"from": {"userid": "user456"},
+					"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+					"msgtype": "text",
+					"text": {"content": "Hello Group"}
+				}`
+
+		// Encrypt message
+		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
+
+		// Create encrypted XML wrapper
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: encrypted,
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, encrypted)
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+		if w.Body.String() != "success" {
+			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
+		}
+	})
+
+	t.Run("missing parameters", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature=sig", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid XML", func(t *testing.T) {
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, "")
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, strings.NewReader("invalid xml"))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
+		}
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: "encrypted_data",
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleMessageCallback(context.Background(), w, req)
+
+		if w.Code != http.StatusForbidden {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
+		}
+	})
+}
+
+func TestWeComBotProcessMessage(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComConfig{
+		Token:      "test_token",
+		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	t.Run("process direct text message", func(t *testing.T) {
+		msg := WeComBotMessage{
+			MsgID:       "test_msg_id_123",
+			AIBotID:     "test_aibot_id",
+			ChatType:    "single",
+			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			MsgType:     "text",
+		}
+		msg.From.UserID = "user123"
+		msg.Text.Content = "Hello World"
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("process group text message", func(t *testing.T) {
+		msg := WeComBotMessage{
+			MsgID:       "test_msg_id_456",
+			AIBotID:     "test_aibot_id",
+			ChatID:      "group_chat_id_123",
+			ChatType:    "group",
+			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			MsgType:     "text",
+		}
+		msg.From.UserID = "user456"
+		msg.Text.Content = "Hello Group"
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("process voice message", func(t *testing.T) {
+		msg := WeComBotMessage{
+			MsgID:       "test_msg_id_789",
+			AIBotID:     "test_aibot_id",
+			ChatType:    "single",
+			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			MsgType:     "voice",
+		}
+		msg.From.UserID = "user123"
+		msg.Voice.Content = "Voice message text"
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+
+	t.Run("skip unsupported message type", func(t *testing.T) {
+		msg := WeComBotMessage{
+			MsgID:       "test_msg_id_000",
+			AIBotID:     "test_aibot_id",
+			ChatType:    "single",
+			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			MsgType:     "video",
+		}
+		msg.From.UserID = "user123"
+
+		// Should not panic
+		ch.processMessage(context.Background(), msg)
+	})
+}
+
+func TestWeComBotHandleWebhook(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComConfig{
+		Token:      "test_token",
+		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	t.Run("GET request calls verification", func(t *testing.T) {
+		echostr := "test_echostr"
+		encoded := base64.StdEncoding.EncodeToString([]byte(echostr))
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, encoded)
+
+		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded, nil)
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+		}
+	})
+
+	t.Run("POST request calls message callback", func(t *testing.T) {
+		encryptedWrapper := struct {
+			XMLName xml.Name `xml:"xml"`
+			Encrypt string   `xml:"Encrypt"`
+		}{
+			Encrypt: base64.StdEncoding.EncodeToString([]byte("test")),
+		}
+		wrapperData, _ := xml.Marshal(encryptedWrapper)
+
+		timestamp := "1234567890"
+		nonce := "test_nonce"
+		signature := generateSignature("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
+
+		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		// Should not be method not allowed
+		if w.Code == http.StatusMethodNotAllowed {
+			t.Error("POST request should not return Method Not Allowed")
+		}
+	})
+
+	t.Run("unsupported method", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPut, "/webhook/wecom", nil)
+		w := httptest.NewRecorder()
+
+		ch.handleWebhook(w, req)
+
+		if w.Code != http.StatusMethodNotAllowed {
+			t.Errorf("status code = %d, want %d", w.Code, http.StatusMethodNotAllowed)
+		}
+	})
+}
+
+func TestWeComBotHandleHealth(t *testing.T) {
+	msgBus := bus.NewMessageBus()
+	cfg := config.WeComConfig{
+		Token:      "test_token",
+		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+	}
+	ch, _ := NewWeComBotChannel(cfg, msgBus)
+
+	req := httptest.NewRequest(http.MethodGet, "/health/wecom", nil)
+	w := httptest.NewRecorder()
+
+	ch.handleHealth(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
+	}
+
+	contentType := w.Header().Get("Content-Type")
+	if contentType != "application/json" {
+		t.Errorf("Content-Type = %q, want %q", contentType, "application/json")
+	}
+
+	body := w.Body.String()
+	if !strings.Contains(body, "status") || !strings.Contains(body, "running") {
+		t.Errorf("response body should contain status and running fields, got: %s", body)
+	}
+}
+
+func TestWeComBotReplyMessage(t *testing.T) {
+	msg := WeComBotReplyMessage{
+		MsgType: "text",
+	}
+	msg.Text.Content = "Hello World"
+
+	if msg.MsgType != "text" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
+	}
+	if msg.Text.Content != "Hello World" {
+		t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
+	}
+}
+
+func TestWeComBotMessageStructure(t *testing.T) {
+	jsonData := `{
+			"msgid": "test_msg_id_123",
+			"aibotid": "test_aibot_id",
+			"chatid": "group_chat_id_123",
+			"chattype": "group",
+			"from": {"userid": "user123"},
+			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			"msgtype": "text",
+			"text": {"content": "Hello World"}
+		}`
+
+	var msg WeComBotMessage
+	err := json.Unmarshal([]byte(jsonData), &msg)
+	if err != nil {
+		t.Fatalf("failed to unmarshal JSON: %v", err)
+	}
+
+	if msg.MsgID != "test_msg_id_123" {
+		t.Errorf("MsgID = %q, want %q", msg.MsgID, "test_msg_id_123")
+	}
+	if msg.AIBotID != "test_aibot_id" {
+		t.Errorf("AIBotID = %q, want %q", msg.AIBotID, "test_aibot_id")
+	}
+	if msg.ChatID != "group_chat_id_123" {
+		t.Errorf("ChatID = %q, want %q", msg.ChatID, "group_chat_id_123")
+	}
+	if msg.ChatType != "group" {
+		t.Errorf("ChatType = %q, want %q", msg.ChatType, "group")
+	}
+	if msg.From.UserID != "user123" {
+		t.Errorf("From.UserID = %q, want %q", msg.From.UserID, "user123")
+	}
+	if msg.MsgType != "text" {
+		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
+	}
+	if msg.Text.Content != "Hello World" {
+		t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
+	}
+}
diff --git a/pkg/channels/wecom/common.go b/pkg/channels/wecom/common.go
new file mode 100644
index 000000000..3c1629577
--- /dev/null
+++ b/pkg/channels/wecom/common.go
@@ -0,0 +1,134 @@
+package wecom
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/binary"
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// blockSize is the PKCS7 block size used by WeCom (32)
+const blockSize = 32
+
+// verifySignature verifies the message signature for WeCom
+// This is a common function used by both WeCom Bot and WeCom App
+func verifySignature(token, msgSignature, timestamp, nonce, msgEncrypt string) bool {
+	if token == "" {
+		return true // Skip verification if token is not set
+	}
+
+	// Sort parameters
+	params := []string{token, timestamp, nonce, msgEncrypt}
+	sort.Strings(params)
+
+	// Concatenate
+	str := strings.Join(params, "")
+
+	// SHA1 hash
+	hash := sha1.Sum([]byte(str))
+	expectedSignature := fmt.Sprintf("%x", hash)
+
+	return expectedSignature == msgSignature
+}
+
+// decryptMessage decrypts the encrypted message using AES
+// For AIBOT, receiveid should be the aibotid; for other apps, it should be corp_id
+func decryptMessage(encryptedMsg, encodingAESKey string) (string, error) {
+	return decryptMessageWithVerify(encryptedMsg, encodingAESKey, "")
+}
+
+// decryptMessageWithVerify decrypts the encrypted message and optionally verifies receiveid
+// receiveid: for AIBOT use aibotid, for WeCom App use corp_id. If empty, skip verification.
+func decryptMessageWithVerify(encryptedMsg, encodingAESKey, receiveid string) (string, error) {
+	if encodingAESKey == "" {
+		// No encryption, return as is (base64 decode)
+		decoded, err := base64.StdEncoding.DecodeString(encryptedMsg)
+		if err != nil {
+			return "", err
+		}
+		return string(decoded), nil
+	}
+
+	// Decode AES key (base64)
+	aesKey, err := base64.StdEncoding.DecodeString(encodingAESKey + "=")
+	if err != nil {
+		return "", fmt.Errorf("failed to decode AES key: %w", err)
+	}
+
+	// Decode encrypted message
+	cipherText, err := base64.StdEncoding.DecodeString(encryptedMsg)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode message: %w", err)
+	}
+
+	// AES decrypt
+	block, err := aes.NewCipher(aesKey)
+	if err != nil {
+		return "", fmt.Errorf("failed to create cipher: %w", err)
+	}
+
+	if len(cipherText) < aes.BlockSize {
+		return "", fmt.Errorf("ciphertext too short")
+	}
+
+	// IV is the first 16 bytes of AESKey
+	iv := aesKey[:aes.BlockSize]
+	mode := cipher.NewCBCDecrypter(block, iv)
+	plainText := make([]byte, len(cipherText))
+	mode.CryptBlocks(plainText, cipherText)
+
+	// Remove PKCS7 padding
+	plainText, err = pkcs7Unpad(plainText)
+	if err != nil {
+		return "", fmt.Errorf("failed to unpad: %w", err)
+	}
+
+	// Parse message structure
+	// Format: random(16) + msg_len(4) + msg + receiveid
+	if len(plainText) < 20 {
+		return "", fmt.Errorf("decrypted message too short")
+	}
+
+	msgLen := binary.BigEndian.Uint32(plainText[16:20])
+	if int(msgLen) > len(plainText)-20 {
+		return "", fmt.Errorf("invalid message length")
+	}
+
+	msg := plainText[20 : 20+msgLen]
+
+	// Verify receiveid if provided
+	if receiveid != "" && len(plainText) > 20+int(msgLen) {
+		actualReceiveID := string(plainText[20+msgLen:])
+		if actualReceiveID != receiveid {
+			return "", fmt.Errorf("receiveid mismatch: expected %s, got %s", receiveid, actualReceiveID)
+		}
+	}
+
+	return string(msg), nil
+}
+
+// pkcs7Unpad removes PKCS7 padding with validation
+func pkcs7Unpad(data []byte) ([]byte, error) {
+	if len(data) == 0 {
+		return data, nil
+	}
+	padding := int(data[len(data)-1])
+	// WeCom uses 32-byte block size for PKCS7 padding
+	if padding == 0 || padding > blockSize {
+		return nil, fmt.Errorf("invalid padding size: %d", padding)
+	}
+	if padding > len(data) {
+		return nil, fmt.Errorf("padding size larger than data")
+	}
+	// Verify all padding bytes
+	for i := 0; i < padding; i++ {
+		if data[len(data)-1-i] != byte(padding) {
+			return nil, fmt.Errorf("invalid padding byte at position %d", i)
+		}
+	}
+	return data[:len(data)-padding], nil
+}
diff --git a/pkg/channels/wecom/init.go b/pkg/channels/wecom/init.go
new file mode 100644
index 000000000..3ef1ecdf3
--- /dev/null
+++ b/pkg/channels/wecom/init.go
@@ -0,0 +1,16 @@
+package wecom
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("wecom", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewWeComBotChannel(cfg.Channels.WeCom, b)
+	})
+	channels.RegisterFactory("wecom_app", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewWeComAppChannel(cfg.Channels.WeComApp, b)
+	})
+}
diff --git a/pkg/channels/whatsapp/init.go b/pkg/channels/whatsapp/init.go
new file mode 100644
index 000000000..d9c2669c3
--- /dev/null
+++ b/pkg/channels/whatsapp/init.go
@@ -0,0 +1,13 @@
+package whatsapp
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("whatsapp", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewWhatsAppChannel(cfg.Channels.WhatsApp, b)
+	})
+}
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
new file mode 100644
index 000000000..1ac256766
--- /dev/null
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -0,0 +1,193 @@
+package whatsapp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/utils"
+)
+
+type WhatsAppChannel struct {
+	*channels.BaseChannel
+	conn      *websocket.Conn
+	config    config.WhatsAppConfig
+	url       string
+	mu        sync.Mutex
+	connected bool
+}
+
+func NewWhatsAppChannel(cfg config.WhatsAppConfig, bus *bus.MessageBus) (*WhatsAppChannel, error) {
+	base := channels.NewBaseChannel("whatsapp", cfg, bus, cfg.AllowFrom)
+
+	return &WhatsAppChannel{
+		BaseChannel: base,
+		config:      cfg,
+		url:         cfg.BridgeURL,
+		connected:   false,
+	}, nil
+}
+
+func (c *WhatsAppChannel) Start(ctx context.Context) error {
+	log.Printf("Starting WhatsApp channel connecting to %s...", c.url)
+
+	dialer := websocket.DefaultDialer
+	dialer.HandshakeTimeout = 10 * time.Second
+
+	conn, _, err := dialer.Dial(c.url, nil)
+	if err != nil {
+		return fmt.Errorf("failed to connect to WhatsApp bridge: %w", err)
+	}
+
+	c.mu.Lock()
+	c.conn = conn
+	c.connected = true
+	c.mu.Unlock()
+
+	c.SetRunning(true)
+	log.Println("WhatsApp channel connected")
+
+	go c.listen(ctx)
+
+	return nil
+}
+
+func (c *WhatsAppChannel) Stop(ctx context.Context) error {
+	log.Println("Stopping WhatsApp channel...")
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.conn != nil {
+		if err := c.conn.Close(); err != nil {
+			log.Printf("Error closing WhatsApp connection: %v", err)
+		}
+		c.conn = nil
+	}
+
+	c.connected = false
+	c.SetRunning(false)
+
+	return nil
+}
+
+func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.conn == nil {
+		return fmt.Errorf("whatsapp connection not established")
+	}
+
+	payload := map[string]interface{}{
+		"type":    "message",
+		"to":      msg.ChatID,
+		"content": msg.Content,
+	}
+
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %w", err)
+	}
+
+	if err := c.conn.WriteMessage(websocket.TextMessage, data); err != nil {
+		return fmt.Errorf("failed to send message: %w", err)
+	}
+
+	return nil
+}
+
+func (c *WhatsAppChannel) listen(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			c.mu.Lock()
+			conn := c.conn
+			c.mu.Unlock()
+
+			if conn == nil {
+				time.Sleep(1 * time.Second)
+				continue
+			}
+
+			_, message, err := conn.ReadMessage()
+			if err != nil {
+				log.Printf("WhatsApp read error: %v", err)
+				time.Sleep(2 * time.Second)
+				continue
+			}
+
+			var msg map[string]interface{}
+			if err := json.Unmarshal(message, &msg); err != nil {
+				log.Printf("Failed to unmarshal WhatsApp message: %v", err)
+				continue
+			}
+
+			msgType, ok := msg["type"].(string)
+			if !ok {
+				continue
+			}
+
+			if msgType == "message" {
+				c.handleIncomingMessage(msg)
+			}
+		}
+	}
+}
+
+func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]interface{}) {
+	senderID, ok := msg["from"].(string)
+	if !ok {
+		return
+	}
+
+	chatID, ok := msg["chat"].(string)
+	if !ok {
+		chatID = senderID
+	}
+
+	content, ok := msg["content"].(string)
+	if !ok {
+		content = ""
+	}
+
+	var mediaPaths []string
+	if mediaData, ok := msg["media"].([]interface{}); ok {
+		mediaPaths = make([]string, 0, len(mediaData))
+		for _, m := range mediaData {
+			if path, ok := m.(string); ok {
+				mediaPaths = append(mediaPaths, path)
+			}
+		}
+	}
+
+	metadata := make(map[string]string)
+	if messageID, ok := msg["id"].(string); ok {
+		metadata["message_id"] = messageID
+	}
+	if userName, ok := msg["from_name"].(string); ok {
+		metadata["user_name"] = userName
+	}
+
+	if chatID == senderID {
+		metadata["peer_kind"] = "direct"
+		metadata["peer_id"] = senderID
+	} else {
+		metadata["peer_kind"] = "group"
+		metadata["peer_id"] = chatID
+	}
+
+	log.Printf("WhatsApp message from %s: %s...", senderID, utils.Truncate(content, 50))
+
+	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+}

From 952ae91501c34cfa290d555c41d5a3b90e6e862e Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Fri, 20 Feb 2026 23:26:33 +0800
Subject: [PATCH 30/52] refactor(channels): remove old channel files from
 parent package

---
 pkg/channels/dingtalk.go          |  204 ------
 pkg/channels/discord.go           |  373 ----------
 pkg/channels/feishu_32.go         |   38 -
 pkg/channels/feishu_64.go         |  227 ------
 pkg/channels/line.go              |  606 ----------------
 pkg/channels/maixcam.go           |  243 -------
 pkg/channels/onebot.go            |  982 -------------------------
 pkg/channels/qq.go                |  247 -------
 pkg/channels/slack.go             |  443 ------------
 pkg/channels/slack_test.go        |  174 -----
 pkg/channels/telegram.go          |  529 --------------
 pkg/channels/telegram_commands.go |  156 ----
 pkg/channels/wecom.go             |  605 ----------------
 pkg/channels/wecom_app.go         |  639 -----------------
 pkg/channels/wecom_app_test.go    | 1104 -----------------------------
 pkg/channels/wecom_test.go        |  785 --------------------
 pkg/channels/whatsapp.go          |  192 -----
 17 files changed, 7547 deletions(-)
 delete mode 100644 pkg/channels/dingtalk.go
 delete mode 100644 pkg/channels/discord.go
 delete mode 100644 pkg/channels/feishu_32.go
 delete mode 100644 pkg/channels/feishu_64.go
 delete mode 100644 pkg/channels/line.go
 delete mode 100644 pkg/channels/maixcam.go
 delete mode 100644 pkg/channels/onebot.go
 delete mode 100644 pkg/channels/qq.go
 delete mode 100644 pkg/channels/slack.go
 delete mode 100644 pkg/channels/slack_test.go
 delete mode 100644 pkg/channels/telegram.go
 delete mode 100644 pkg/channels/telegram_commands.go
 delete mode 100644 pkg/channels/wecom.go
 delete mode 100644 pkg/channels/wecom_app.go
 delete mode 100644 pkg/channels/wecom_app_test.go
 delete mode 100644 pkg/channels/wecom_test.go
 delete mode 100644 pkg/channels/whatsapp.go

diff --git a/pkg/channels/dingtalk.go b/pkg/channels/dingtalk.go
deleted file mode 100644
index 662fba3b7..000000000
--- a/pkg/channels/dingtalk.go
+++ /dev/null
@@ -1,204 +0,0 @@
-// PicoClaw - Ultra-lightweight personal AI agent
-// DingTalk channel implementation using Stream Mode
-
-package channels
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot"
-	"github.com/open-dingtalk/dingtalk-stream-sdk-go/client"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-// DingTalkChannel implements the Channel interface for DingTalk (钉钉)
-// It uses WebSocket for receiving messages via stream mode and API for sending
-type DingTalkChannel struct {
-	*BaseChannel
-	config       config.DingTalkConfig
-	clientID     string
-	clientSecret string
-	streamClient *client.StreamClient
-	ctx          context.Context
-	cancel       context.CancelFunc
-	// Map to store session webhooks for each chat
-	sessionWebhooks sync.Map // chatID -> sessionWebhook
-}
-
-// NewDingTalkChannel creates a new DingTalk channel instance
-func NewDingTalkChannel(cfg config.DingTalkConfig, messageBus *bus.MessageBus) (*DingTalkChannel, error) {
-	if cfg.ClientID == "" || cfg.ClientSecret == "" {
-		return nil, fmt.Errorf("dingtalk client_id and client_secret are required")
-	}
-
-	base := NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom)
-
-	return &DingTalkChannel{
-		BaseChannel:  base,
-		config:       cfg,
-		clientID:     cfg.ClientID,
-		clientSecret: cfg.ClientSecret,
-	}, nil
-}
-
-// Start initializes the DingTalk channel with Stream Mode
-func (c *DingTalkChannel) Start(ctx context.Context) error {
-	logger.InfoC("dingtalk", "Starting DingTalk channel (Stream Mode)...")
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	// Create credential config
-	cred := client.NewAppCredentialConfig(c.clientID, c.clientSecret)
-
-	// Create the stream client with options
-	c.streamClient = client.NewStreamClient(
-		client.WithAppCredential(cred),
-		client.WithAutoReconnect(true),
-	)
-
-	// Register chatbot callback handler (IChatBotMessageHandler is a function type)
-	c.streamClient.RegisterChatBotCallbackRouter(c.onChatBotMessageReceived)
-
-	// Start the stream client
-	if err := c.streamClient.Start(c.ctx); err != nil {
-		return fmt.Errorf("failed to start stream client: %w", err)
-	}
-
-	c.setRunning(true)
-	logger.InfoC("dingtalk", "DingTalk channel started (Stream Mode)")
-	return nil
-}
-
-// Stop gracefully stops the DingTalk channel
-func (c *DingTalkChannel) Stop(ctx context.Context) error {
-	logger.InfoC("dingtalk", "Stopping DingTalk channel...")
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	if c.streamClient != nil {
-		c.streamClient.Close()
-	}
-
-	c.setRunning(false)
-	logger.InfoC("dingtalk", "DingTalk channel stopped")
-	return nil
-}
-
-// Send sends a message to DingTalk via the chatbot reply API
-func (c *DingTalkChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("dingtalk channel not running")
-	}
-
-	// Get session webhook from storage
-	sessionWebhookRaw, ok := c.sessionWebhooks.Load(msg.ChatID)
-	if !ok {
-		return fmt.Errorf("no session_webhook found for chat %s, cannot send message", msg.ChatID)
-	}
-
-	sessionWebhook, ok := sessionWebhookRaw.(string)
-	if !ok {
-		return fmt.Errorf("invalid session_webhook type for chat %s", msg.ChatID)
-	}
-
-	logger.DebugCF("dingtalk", "Sending message", map[string]any{
-		"chat_id": msg.ChatID,
-		"preview": utils.Truncate(msg.Content, 100),
-	})
-
-	// Use the session webhook to send the reply
-	return c.SendDirectReply(ctx, sessionWebhook, msg.Content)
-}
-
-// onChatBotMessageReceived implements the IChatBotMessageHandler function signature
-// This is called by the Stream SDK when a new message arrives
-// IChatBotMessageHandler is: func(c context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error)
-func (c *DingTalkChannel) onChatBotMessageReceived(
-	ctx context.Context,
-	data *chatbot.BotCallbackDataModel,
-) ([]byte, error) {
-	// Extract message content from Text field
-	content := data.Text.Content
-	if content == "" {
-		// Try to extract from Content interface{} if Text is empty
-		if contentMap, ok := data.Content.(map[string]any); ok {
-			if textContent, ok := contentMap["content"].(string); ok {
-				content = textContent
-			}
-		}
-	}
-
-	if content == "" {
-		return nil, nil // Ignore empty messages
-	}
-
-	senderID := data.SenderStaffId
-	senderNick := data.SenderNick
-	chatID := senderID
-	if data.ConversationType != "1" {
-		// For group chats
-		chatID = data.ConversationId
-	}
-
-	// Store the session webhook for this chat so we can reply later
-	c.sessionWebhooks.Store(chatID, data.SessionWebhook)
-
-	metadata := map[string]string{
-		"sender_name":       senderNick,
-		"conversation_id":   data.ConversationId,
-		"conversation_type": data.ConversationType,
-		"platform":          "dingtalk",
-		"session_webhook":   data.SessionWebhook,
-	}
-
-	if data.ConversationType == "1" {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
-	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = data.ConversationId
-	}
-
-	logger.DebugCF("dingtalk", "Received message", map[string]any{
-		"sender_nick": senderNick,
-		"sender_id":   senderID,
-		"preview":     utils.Truncate(content, 50),
-	})
-
-	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-
-	// Return nil to indicate we've handled the message asynchronously
-	// The response will be sent through the message bus
-	return nil, nil
-}
-
-// SendDirectReply sends a direct reply using the session webhook
-func (c *DingTalkChannel) SendDirectReply(ctx context.Context, sessionWebhook, content string) error {
-	replier := chatbot.NewChatbotReplier()
-
-	// Convert string content to []byte for the API
-	contentBytes := []byte(content)
-	titleBytes := []byte("PicoClaw")
-
-	// Send markdown formatted reply
-	err := replier.SimpleReplyMarkdown(
-		ctx,
-		sessionWebhook,
-		titleBytes,
-		contentBytes,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to send reply: %w", err)
-	}
-
-	return nil
-}
diff --git a/pkg/channels/discord.go b/pkg/channels/discord.go
deleted file mode 100644
index 20f3b267c..000000000
--- a/pkg/channels/discord.go
+++ /dev/null
@@ -1,373 +0,0 @@
-package channels
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/bwmarrin/discordgo"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
-)
-
-const (
-	transcriptionTimeout = 30 * time.Second
-	sendTimeout          = 10 * time.Second
-)
-
-type DiscordChannel struct {
-	*BaseChannel
-	session     *discordgo.Session
-	config      config.DiscordConfig
-	transcriber *voice.GroqTranscriber
-	ctx         context.Context
-	typingMu    sync.Mutex
-	typingStop  map[string]chan struct{} // chatID → stop signal
-	botUserID   string                   // stored for mention checking
-}
-
-func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordChannel, error) {
-	session, err := discordgo.New("Bot " + cfg.Token)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create discord session: %w", err)
-	}
-
-	base := NewBaseChannel("discord", cfg, bus, cfg.AllowFrom)
-
-	return &DiscordChannel{
-		BaseChannel: base,
-		session:     session,
-		config:      cfg,
-		transcriber: nil,
-		ctx:         context.Background(),
-		typingStop:  make(map[string]chan struct{}),
-	}, nil
-}
-
-func (c *DiscordChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
-func (c *DiscordChannel) getContext() context.Context {
-	if c.ctx == nil {
-		return context.Background()
-	}
-	return c.ctx
-}
-
-func (c *DiscordChannel) Start(ctx context.Context) error {
-	logger.InfoC("discord", "Starting Discord bot")
-
-	c.ctx = ctx
-
-	// Get bot user ID before opening session to avoid race condition
-	botUser, err := c.session.User("@me")
-	if err != nil {
-		return fmt.Errorf("failed to get bot user: %w", err)
-	}
-	c.botUserID = botUser.ID
-
-	c.session.AddHandler(c.handleMessage)
-
-	if err := c.session.Open(); err != nil {
-		return fmt.Errorf("failed to open discord session: %w", err)
-	}
-
-	c.setRunning(true)
-
-	logger.InfoCF("discord", "Discord bot connected", map[string]any{
-		"username": botUser.Username,
-		"user_id":  botUser.ID,
-	})
-
-	return nil
-}
-
-func (c *DiscordChannel) Stop(ctx context.Context) error {
-	logger.InfoC("discord", "Stopping Discord bot")
-	c.setRunning(false)
-
-	// Stop all typing goroutines before closing session
-	c.typingMu.Lock()
-	for chatID, stop := range c.typingStop {
-		close(stop)
-		delete(c.typingStop, chatID)
-	}
-	c.typingMu.Unlock()
-
-	if err := c.session.Close(); err != nil {
-		return fmt.Errorf("failed to close discord session: %w", err)
-	}
-
-	return nil
-}
-
-func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	c.stopTyping(msg.ChatID)
-
-	if !c.IsRunning() {
-		return fmt.Errorf("discord bot not running")
-	}
-
-	channelID := msg.ChatID
-	if channelID == "" {
-		return fmt.Errorf("channel ID is empty")
-	}
-
-	runes := []rune(msg.Content)
-	if len(runes) == 0 {
-		return nil
-	}
-
-	chunks := utils.SplitMessage(msg.Content, 2000) // Split messages into chunks, Discord length limit: 2000 chars
-
-	for _, chunk := range chunks {
-		if err := c.sendChunk(ctx, channelID, chunk); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
-	// Use the passed ctx for timeout control
-	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
-	defer cancel()
-
-	done := make(chan error, 1)
-	go func() {
-		_, err := c.session.ChannelMessageSend(channelID, content)
-		done <- err
-	}()
-
-	select {
-	case err := <-done:
-		if err != nil {
-			return fmt.Errorf("failed to send discord message: %w", err)
-		}
-		return nil
-	case <-sendCtx.Done():
-		return fmt.Errorf("send message timeout: %w", sendCtx.Err())
-	}
-}
-
-// appendContent safely appends content to existing text
-func appendContent(content, suffix string) string {
-	if content == "" {
-		return suffix
-	}
-	return content + "\n" + suffix
-}
-
-func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.MessageCreate) {
-	if m == nil || m.Author == nil {
-		return
-	}
-
-	if m.Author.ID == s.State.User.ID {
-		return
-	}
-
-	// Check allowlist first to avoid downloading attachments and transcribing for rejected users
-	if !c.IsAllowed(m.Author.ID) {
-		logger.DebugCF("discord", "Message rejected by allowlist", map[string]any{
-			"user_id": m.Author.ID,
-		})
-		return
-	}
-
-	// If configured to only respond to mentions, check if bot is mentioned
-	// Skip this check for DMs (GuildID is empty) - DMs should always be responded to
-	if c.config.MentionOnly && m.GuildID != "" {
-		isMentioned := false
-		for _, mention := range m.Mentions {
-			if mention.ID == c.botUserID {
-				isMentioned = true
-				break
-			}
-		}
-		if !isMentioned {
-			logger.DebugCF("discord", "Message ignored - bot not mentioned", map[string]any{
-				"user_id": m.Author.ID,
-			})
-			return
-		}
-	}
-
-	senderID := m.Author.ID
-	senderName := m.Author.Username
-	if m.Author.Discriminator != "" && m.Author.Discriminator != "0" {
-		senderName += "#" + m.Author.Discriminator
-	}
-
-	content := m.Content
-	content = c.stripBotMention(content)
-	mediaPaths := make([]string, 0, len(m.Attachments))
-	localFiles := make([]string, 0, len(m.Attachments))
-
-	// Ensure temp files are cleaned up when function returns
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("discord", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
-			}
-		}
-	}()
-
-	for _, attachment := range m.Attachments {
-		isAudio := utils.IsAudioFile(attachment.Filename, attachment.ContentType)
-
-		if isAudio {
-			localPath := c.downloadAttachment(attachment.URL, attachment.Filename)
-			if localPath != "" {
-				localFiles = append(localFiles, localPath)
-
-				transcribedText := ""
-				if c.transcriber != nil && c.transcriber.IsAvailable() {
-					ctx, cancel := context.WithTimeout(c.getContext(), transcriptionTimeout)
-					result, err := c.transcriber.Transcribe(ctx, localPath)
-					cancel() // Release context resources immediately to avoid leaks in for loop
-
-					if err != nil {
-						logger.ErrorCF("discord", "Voice transcription failed", map[string]any{
-							"error": err.Error(),
-						})
-						transcribedText = fmt.Sprintf("[audio: %s (transcription failed)]", attachment.Filename)
-					} else {
-						transcribedText = fmt.Sprintf("[audio transcription: %s]", result.Text)
-						logger.DebugCF("discord", "Audio transcribed successfully", map[string]any{
-							"text": result.Text,
-						})
-					}
-				} else {
-					transcribedText = fmt.Sprintf("[audio: %s]", attachment.Filename)
-				}
-
-				content = appendContent(content, transcribedText)
-			} 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))
-			}
-		} else {
-			mediaPaths = append(mediaPaths, attachment.URL)
-			content = appendContent(content, fmt.Sprintf("[attachment: %s]", attachment.URL))
-		}
-	}
-
-	if content == "" && len(mediaPaths) == 0 {
-		return
-	}
-
-	if content == "" {
-		content = "[media only]"
-	}
-
-	// Start typing after all early returns — guaranteed to have a matching Send()
-	c.startTyping(m.ChannelID)
-
-	logger.DebugCF("discord", "Received message", map[string]any{
-		"sender_name": senderName,
-		"sender_id":   senderID,
-		"preview":     utils.Truncate(content, 50),
-	})
-
-	peerKind := "channel"
-	peerID := m.ChannelID
-	if m.GuildID == "" {
-		peerKind = "direct"
-		peerID = senderID
-	}
-
-	metadata := map[string]string{
-		"message_id":   m.ID,
-		"user_id":      senderID,
-		"username":     m.Author.Username,
-		"display_name": senderName,
-		"guild_id":     m.GuildID,
-		"channel_id":   m.ChannelID,
-		"is_dm":        fmt.Sprintf("%t", m.GuildID == ""),
-		"peer_kind":    peerKind,
-		"peer_id":      peerID,
-	}
-
-	c.HandleMessage(senderID, m.ChannelID, content, mediaPaths, metadata)
-}
-
-// startTyping starts a continuous typing indicator loop for the given chatID.
-// It stops any existing typing loop for that chatID before starting a new one.
-func (c *DiscordChannel) startTyping(chatID string) {
-	c.typingMu.Lock()
-	// Stop existing loop for this chatID if any
-	if stop, ok := c.typingStop[chatID]; ok {
-		close(stop)
-	}
-	stop := make(chan struct{})
-	c.typingStop[chatID] = stop
-	c.typingMu.Unlock()
-
-	go func() {
-		if err := c.session.ChannelTyping(chatID); err != nil {
-			logger.DebugCF("discord", "ChannelTyping error", map[string]any{"chatID": chatID, "err": err})
-		}
-		ticker := time.NewTicker(8 * time.Second)
-		defer ticker.Stop()
-		timeout := time.After(5 * time.Minute)
-		for {
-			select {
-			case <-stop:
-				return
-			case <-timeout:
-				return
-			case <-c.ctx.Done():
-				return
-			case <-ticker.C:
-				if err := c.session.ChannelTyping(chatID); err != nil {
-					logger.DebugCF("discord", "ChannelTyping error", map[string]any{"chatID": chatID, "err": err})
-				}
-			}
-		}
-	}()
-}
-
-// stopTyping stops the typing indicator loop for the given chatID.
-func (c *DiscordChannel) stopTyping(chatID string) {
-	c.typingMu.Lock()
-	defer c.typingMu.Unlock()
-	if stop, ok := c.typingStop[chatID]; ok {
-		close(stop)
-		delete(c.typingStop, chatID)
-	}
-}
-
-func (c *DiscordChannel) downloadAttachment(url, filename string) string {
-	return utils.DownloadFile(url, filename, utils.DownloadOptions{
-		LoggerPrefix: "discord",
-	})
-}
-
-// stripBotMention removes the bot mention from the message content.
-// Discord mentions have the format <@USER_ID> or <@!USER_ID> (with nickname).
-func (c *DiscordChannel) stripBotMention(text string) string {
-	if c.botUserID == "" {
-		return text
-	}
-	// Remove both regular mention <@USER_ID> and nickname mention <@!USER_ID>
-	text = strings.ReplaceAll(text, fmt.Sprintf("<@%s>", c.botUserID), "")
-	text = strings.ReplaceAll(text, fmt.Sprintf("<@!%s>", c.botUserID), "")
-	return strings.TrimSpace(text)
-}
diff --git a/pkg/channels/feishu_32.go b/pkg/channels/feishu_32.go
deleted file mode 100644
index 5109b8195..000000000
--- a/pkg/channels/feishu_32.go
+++ /dev/null
@@ -1,38 +0,0 @@
-//go:build !amd64 && !arm64 && !riscv64 && !mips64 && !ppc64
-
-package channels
-
-import (
-	"context"
-	"errors"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-// FeishuChannel is a stub implementation for 32-bit architectures
-type FeishuChannel struct {
-	*BaseChannel
-}
-
-// 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 nil
-}
-
-// Stop is a stub method to satisfy the Channel interface
-func (c *FeishuChannel) Stop(ctx context.Context) error {
-	return nil
-}
-
-// Send is a stub method to satisfy the Channel interface
-func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	return errors.New("feishu channel is not supported on 32-bit architectures")
-}
diff --git a/pkg/channels/feishu_64.go b/pkg/channels/feishu_64.go
deleted file mode 100644
index 42e74980f..000000000
--- a/pkg/channels/feishu_64.go
+++ /dev/null
@@ -1,227 +0,0 @@
-//go:build amd64 || arm64 || riscv64 || mips64 || ppc64
-
-package channels
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"sync"
-	"time"
-
-	lark "github.com/larksuite/oapi-sdk-go/v3"
-	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"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-type FeishuChannel struct {
-	*BaseChannel
-	config   config.FeishuConfig
-	client   *lark.Client
-	wsClient *larkws.Client
-
-	mu     sync.Mutex
-	cancel context.CancelFunc
-}
-
-func NewFeishuChannel(cfg config.FeishuConfig, bus *bus.MessageBus) (*FeishuChannel, error) {
-	base := NewBaseChannel("feishu", cfg, bus, cfg.AllowFrom)
-
-	return &FeishuChannel{
-		BaseChannel: base,
-		config:      cfg,
-		client:      lark.NewClient(cfg.AppID, cfg.AppSecret),
-	}, 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")
-	}
-
-	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
-}
-
-func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("feishu channel not running")
-	}
-
-	if msg.ChatID == "" {
-		return fmt.Errorf("chat ID is empty")
-	}
-
-	payload, err := json.Marshal(map[string]string{"text": msg.Content})
-	if err != nil {
-		return fmt.Errorf("failed to marshal feishu content: %w", err)
-	}
-
-	req := larkim.NewCreateMessageReqBuilder().
-		ReceiveIdType(larkim.ReceiveIdTypeChatId).
-		Body(larkim.NewCreateMessageReqBodyBuilder().
-			ReceiveId(msg.ChatID).
-			MsgType(larkim.MsgTypeText).
-			Content(string(payload)).
-			Uuid(fmt.Sprintf("picoclaw-%d", time.Now().UnixNano())).
-			Build()).
-		Build()
-
-	resp, err := c.client.Im.V1.Message.Create(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to send feishu message: %w", err)
-	}
-
-	if !resp.Success() {
-		return fmt.Errorf("feishu api error: code=%d msg=%s", resp.Code, resp.Msg)
-	}
-
-	logger.DebugCF("feishu", "Feishu message sent", map[string]any{
-		"chat_id": msg.ChatID,
-	})
-
-	return nil
-}
-
-func (c *FeishuChannel) handleMessageReceive(_ 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"
-	}
-
-	content := extractFeishuMessageContent(message)
-	if content == "" {
-		content = "[empty message]"
-	}
-
-	metadata := map[string]string{}
-	if messageID := stringValue(message.MessageId); messageID != "" {
-		metadata["message_id"] = messageID
-	}
-	if messageType := stringValue(message.MessageType); messageType != "" {
-		metadata["message_type"] = messageType
-	}
-	if chatType := stringValue(message.ChatType); chatType != "" {
-		metadata["chat_type"] = chatType
-	}
-	if sender != nil && sender.TenantKey != nil {
-		metadata["tenant_key"] = *sender.TenantKey
-	}
-
-	chatType := stringValue(message.ChatType)
-	if chatType == "p2p" {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
-	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
-	}
-
-	logger.InfoCF("feishu", "Feishu message received", map[string]any{
-		"sender_id": senderID,
-		"chat_id":   chatID,
-		"preview":   utils.Truncate(content, 80),
-	})
-
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-	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 ""
-}
-
-func extractFeishuMessageContent(message *larkim.EventMessage) string {
-	if message == nil || message.Content == nil || *message.Content == "" {
-		return ""
-	}
-
-	if message.MessageType != nil && *message.MessageType == larkim.MsgTypeText {
-		var textPayload struct {
-			Text string `json:"text"`
-		}
-		if err := json.Unmarshal([]byte(*message.Content), &textPayload); err == nil {
-			return textPayload.Text
-		}
-	}
-
-	return *message.Content
-}
-
-func stringValue(v *string) string {
-	if v == nil {
-		return ""
-	}
-	return *v
-}
diff --git a/pkg/channels/line.go b/pkg/channels/line.go
deleted file mode 100644
index 44134996f..000000000
--- a/pkg/channels/line.go
+++ /dev/null
@@ -1,606 +0,0 @@
-package channels
-
-import (
-	"bytes"
-	"context"
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-const (
-	lineAPIBase          = "https://api.line.me/v2/bot"
-	lineDataAPIBase      = "https://api-data.line.me/v2/bot"
-	lineReplyEndpoint    = lineAPIBase + "/message/reply"
-	linePushEndpoint     = lineAPIBase + "/message/push"
-	lineContentEndpoint  = lineDataAPIBase + "/message/%s/content"
-	lineBotInfoEndpoint  = lineAPIBase + "/info"
-	lineLoadingEndpoint  = lineAPIBase + "/chat/loading/start"
-	lineReplyTokenMaxAge = 25 * time.Second
-)
-
-type replyTokenEntry struct {
-	token     string
-	timestamp time.Time
-}
-
-// LINEChannel implements the Channel interface for LINE Official Account
-// using the LINE Messaging API with HTTP webhook for receiving messages
-// and REST API for sending messages.
-type LINEChannel struct {
-	*BaseChannel
-	config         config.LINEConfig
-	httpServer     *http.Server
-	botUserID      string   // Bot's user ID
-	botBasicID     string   // Bot's basic ID (e.g. @216ru...)
-	botDisplayName string   // Bot's display name for text-based mention detection
-	replyTokens    sync.Map // chatID -> replyTokenEntry
-	quoteTokens    sync.Map // chatID -> quoteToken (string)
-	ctx            context.Context
-	cancel         context.CancelFunc
-}
-
-// NewLINEChannel creates a new LINE channel instance.
-func NewLINEChannel(cfg config.LINEConfig, messageBus *bus.MessageBus) (*LINEChannel, error) {
-	if cfg.ChannelSecret == "" || cfg.ChannelAccessToken == "" {
-		return nil, fmt.Errorf("line channel_secret and channel_access_token are required")
-	}
-
-	base := NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom)
-
-	return &LINEChannel{
-		BaseChannel: base,
-		config:      cfg,
-	}, nil
-}
-
-// Start launches the HTTP webhook server.
-func (c *LINEChannel) Start(ctx context.Context) error {
-	logger.InfoC("line", "Starting LINE channel (Webhook Mode)")
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	// Fetch bot profile to get bot's userId for mention detection
-	if err := c.fetchBotInfo(); err != nil {
-		logger.WarnCF("line", "Failed to fetch bot info (mention detection disabled)", map[string]any{
-			"error": err.Error(),
-		})
-	} else {
-		logger.InfoCF("line", "Bot info fetched", map[string]any{
-			"bot_user_id":  c.botUserID,
-			"basic_id":     c.botBasicID,
-			"display_name": c.botDisplayName,
-		})
-	}
-
-	mux := http.NewServeMux()
-	path := c.config.WebhookPath
-	if path == "" {
-		path = "/webhook/line"
-	}
-	mux.HandleFunc(path, c.webhookHandler)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.httpServer = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
-	go func() {
-		logger.InfoCF("line", "LINE webhook server listening", map[string]any{
-			"addr": addr,
-			"path": path,
-		})
-		if err := c.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("line", "Webhook server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
-
-	c.setRunning(true)
-	logger.InfoC("line", "LINE channel started (Webhook Mode)")
-	return nil
-}
-
-// fetchBotInfo retrieves the bot's userId, basicId, and displayName from the LINE API.
-func (c *LINEChannel) fetchBotInfo() error {
-	req, err := http.NewRequest(http.MethodGet, lineBotInfoEndpoint, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Authorization", "Bearer "+c.config.ChannelAccessToken)
-
-	client := &http.Client{Timeout: 10 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("bot info API returned status %d", resp.StatusCode)
-	}
-
-	var info struct {
-		UserID      string `json:"userId"`
-		BasicID     string `json:"basicId"`
-		DisplayName string `json:"displayName"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
-		return err
-	}
-
-	c.botUserID = info.UserID
-	c.botBasicID = info.BasicID
-	c.botDisplayName = info.DisplayName
-	return nil
-}
-
-// Stop gracefully shuts down the HTTP server.
-func (c *LINEChannel) Stop(ctx context.Context) error {
-	logger.InfoC("line", "Stopping LINE channel")
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	if c.httpServer != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		if err := c.httpServer.Shutdown(shutdownCtx); err != nil {
-			logger.ErrorCF("line", "Webhook server shutdown error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}
-
-	c.setRunning(false)
-	logger.InfoC("line", "LINE channel stopped")
-	return nil
-}
-
-// webhookHandler handles incoming LINE webhook requests.
-func (c *LINEChannel) webhookHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		logger.ErrorCF("line", "Failed to read request body", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Bad request", http.StatusBadRequest)
-		return
-	}
-
-	signature := r.Header.Get("X-Line-Signature")
-	if !c.verifySignature(body, signature) {
-		logger.WarnC("line", "Invalid webhook signature")
-		http.Error(w, "Forbidden", http.StatusForbidden)
-		return
-	}
-
-	var payload struct {
-		Events []lineEvent `json:"events"`
-	}
-	if err := json.Unmarshal(body, &payload); err != nil {
-		logger.ErrorCF("line", "Failed to parse webhook payload", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Bad request", http.StatusBadRequest)
-		return
-	}
-
-	// Return 200 immediately, process events asynchronously
-	w.WriteHeader(http.StatusOK)
-
-	for _, event := range payload.Events {
-		go c.processEvent(event)
-	}
-}
-
-// verifySignature validates the X-Line-Signature using HMAC-SHA256.
-func (c *LINEChannel) verifySignature(body []byte, signature string) bool {
-	if signature == "" {
-		return false
-	}
-
-	mac := hmac.New(sha256.New, []byte(c.config.ChannelSecret))
-	mac.Write(body)
-	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
-
-	return hmac.Equal([]byte(expected), []byte(signature))
-}
-
-// LINE webhook event types
-type lineEvent struct {
-	Type       string          `json:"type"`
-	ReplyToken string          `json:"replyToken"`
-	Source     lineSource      `json:"source"`
-	Message    json.RawMessage `json:"message"`
-	Timestamp  int64           `json:"timestamp"`
-}
-
-type lineSource struct {
-	Type    string `json:"type"` // "user", "group", "room"
-	UserID  string `json:"userId"`
-	GroupID string `json:"groupId"`
-	RoomID  string `json:"roomId"`
-}
-
-type lineMessage struct {
-	ID         string `json:"id"`
-	Type       string `json:"type"` // "text", "image", "video", "audio", "file", "sticker"
-	Text       string `json:"text"`
-	QuoteToken string `json:"quoteToken"`
-	Mention    *struct {
-		Mentionees []lineMentionee `json:"mentionees"`
-	} `json:"mention"`
-	ContentProvider struct {
-		Type string `json:"type"`
-	} `json:"contentProvider"`
-}
-
-type lineMentionee struct {
-	Index  int    `json:"index"`
-	Length int    `json:"length"`
-	Type   string `json:"type"` // "user", "all"
-	UserID string `json:"userId"`
-}
-
-func (c *LINEChannel) processEvent(event lineEvent) {
-	if event.Type != "message" {
-		logger.DebugCF("line", "Ignoring non-message event", map[string]any{
-			"type": event.Type,
-		})
-		return
-	}
-
-	senderID := event.Source.UserID
-	chatID := c.resolveChatID(event.Source)
-	isGroup := event.Source.Type == "group" || event.Source.Type == "room"
-
-	var msg lineMessage
-	if err := json.Unmarshal(event.Message, &msg); err != nil {
-		logger.ErrorCF("line", "Failed to parse message", map[string]any{
-			"error": err.Error(),
-		})
-		return
-	}
-
-	// In group chats, only respond when the bot is mentioned
-	if isGroup && !c.isBotMentioned(msg) {
-		logger.DebugCF("line", "Ignoring group message without mention", map[string]any{
-			"chat_id": chatID,
-		})
-		return
-	}
-
-	// Store reply token for later use
-	if event.ReplyToken != "" {
-		c.replyTokens.Store(chatID, replyTokenEntry{
-			token:     event.ReplyToken,
-			timestamp: time.Now(),
-		})
-	}
-
-	// Store quote token for quoting the original message in reply
-	if msg.QuoteToken != "" {
-		c.quoteTokens.Store(chatID, msg.QuoteToken)
-	}
-
-	var content string
-	var mediaPaths []string
-	localFiles := []string{}
-
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("line", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
-			}
-		}
-	}()
-
-	switch msg.Type {
-	case "text":
-		content = msg.Text
-		// Strip bot mention from text in group chats
-		if isGroup {
-			content = c.stripBotMention(content, msg)
-		}
-	case "image":
-		localPath := c.downloadContent(msg.ID, "image.jpg")
-		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
-			content = "[image]"
-		}
-	case "audio":
-		localPath := c.downloadContent(msg.ID, "audio.m4a")
-		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
-			content = "[audio]"
-		}
-	case "video":
-		localPath := c.downloadContent(msg.ID, "video.mp4")
-		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
-			content = "[video]"
-		}
-	case "file":
-		content = "[file]"
-	case "sticker":
-		content = "[sticker]"
-	default:
-		content = fmt.Sprintf("[%s]", msg.Type)
-	}
-
-	if strings.TrimSpace(content) == "" {
-		return
-	}
-
-	metadata := map[string]string{
-		"platform":    "line",
-		"source_type": event.Source.Type,
-		"message_id":  msg.ID,
-	}
-
-	if isGroup {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
-	} else {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
-	}
-
-	logger.DebugCF("line", "Received message", map[string]any{
-		"sender_id":    senderID,
-		"chat_id":      chatID,
-		"message_type": msg.Type,
-		"is_group":     isGroup,
-		"preview":      utils.Truncate(content, 50),
-	})
-
-	// Show typing/loading indicator (requires user ID, not group ID)
-	c.sendLoading(senderID)
-
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
-}
-
-// isBotMentioned checks if the bot is mentioned in the message.
-// It first checks the mention metadata (userId match), then falls back
-// to text-based detection using the bot's display name, since LINE may
-// not include userId in mentionees for Official Accounts.
-func (c *LINEChannel) isBotMentioned(msg lineMessage) bool {
-	// Check mention metadata
-	if msg.Mention != nil {
-		for _, m := range msg.Mention.Mentionees {
-			if m.Type == "all" {
-				return true
-			}
-			if c.botUserID != "" && m.UserID == c.botUserID {
-				return true
-			}
-		}
-		// Mention metadata exists with mentionees but bot not matched by userId.
-		// The bot IS likely mentioned (LINE includes mention struct when bot is @-ed),
-		// so check if any mentionee overlaps with bot display name in text.
-		if c.botDisplayName != "" {
-			for _, m := range msg.Mention.Mentionees {
-				if m.Index >= 0 && m.Length > 0 {
-					runes := []rune(msg.Text)
-					end := m.Index + m.Length
-					if end <= len(runes) {
-						mentionText := string(runes[m.Index:end])
-						if strings.Contains(mentionText, c.botDisplayName) {
-							return true
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Fallback: text-based detection with display name
-	if c.botDisplayName != "" && strings.Contains(msg.Text, "@"+c.botDisplayName) {
-		return true
-	}
-
-	return false
-}
-
-// stripBotMention removes the @BotName mention text from the message.
-func (c *LINEChannel) stripBotMention(text string, msg lineMessage) string {
-	stripped := false
-
-	// Try to strip using mention metadata indices
-	if msg.Mention != nil {
-		runes := []rune(text)
-		for i := len(msg.Mention.Mentionees) - 1; i >= 0; i-- {
-			m := msg.Mention.Mentionees[i]
-			// Strip if userId matches OR if the mention text contains the bot display name
-			shouldStrip := false
-			if c.botUserID != "" && m.UserID == c.botUserID {
-				shouldStrip = true
-			} else if c.botDisplayName != "" && m.Index >= 0 && m.Length > 0 {
-				end := m.Index + m.Length
-				if end <= len(runes) {
-					mentionText := string(runes[m.Index:end])
-					if strings.Contains(mentionText, c.botDisplayName) {
-						shouldStrip = true
-					}
-				}
-			}
-			if shouldStrip {
-				start := m.Index
-				end := m.Index + m.Length
-				if start >= 0 && end <= len(runes) {
-					runes = append(runes[:start], runes[end:]...)
-					stripped = true
-				}
-			}
-		}
-		if stripped {
-			return strings.TrimSpace(string(runes))
-		}
-	}
-
-	// Fallback: strip @DisplayName from text
-	if c.botDisplayName != "" {
-		text = strings.ReplaceAll(text, "@"+c.botDisplayName, "")
-	}
-
-	return strings.TrimSpace(text)
-}
-
-// resolveChatID determines the chat ID from the event source.
-// For group/room messages, use the group/room ID; for 1:1, use the user ID.
-func (c *LINEChannel) resolveChatID(source lineSource) string {
-	switch source.Type {
-	case "group":
-		return source.GroupID
-	case "room":
-		return source.RoomID
-	default:
-		return source.UserID
-	}
-}
-
-// Send sends a message to LINE. It first tries the Reply API (free)
-// using a cached reply token, then falls back to the Push API.
-func (c *LINEChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("line channel not running")
-	}
-
-	// Load and consume quote token for this chat
-	var quoteToken string
-	if qt, ok := c.quoteTokens.LoadAndDelete(msg.ChatID); ok {
-		quoteToken = qt.(string)
-	}
-
-	// Try reply token first (free, valid for ~25 seconds)
-	if entry, ok := c.replyTokens.LoadAndDelete(msg.ChatID); ok {
-		tokenEntry := entry.(replyTokenEntry)
-		if time.Since(tokenEntry.timestamp) < lineReplyTokenMaxAge {
-			if err := c.sendReply(ctx, tokenEntry.token, msg.Content, quoteToken); err == nil {
-				logger.DebugCF("line", "Message sent via Reply API", map[string]any{
-					"chat_id": msg.ChatID,
-					"quoted":  quoteToken != "",
-				})
-				return nil
-			}
-			logger.DebugC("line", "Reply API failed, falling back to Push API")
-		}
-	}
-
-	// Fall back to Push API
-	return c.sendPush(ctx, msg.ChatID, msg.Content, quoteToken)
-}
-
-// buildTextMessage creates a text message object, optionally with quoteToken.
-func buildTextMessage(content, quoteToken string) map[string]string {
-	msg := map[string]string{
-		"type": "text",
-		"text": content,
-	}
-	if quoteToken != "" {
-		msg["quoteToken"] = quoteToken
-	}
-	return msg
-}
-
-// sendReply sends a message using the LINE Reply API.
-func (c *LINEChannel) sendReply(ctx context.Context, replyToken, content, quoteToken string) error {
-	payload := map[string]any{
-		"replyToken": replyToken,
-		"messages":   []map[string]string{buildTextMessage(content, quoteToken)},
-	}
-
-	return c.callAPI(ctx, lineReplyEndpoint, payload)
-}
-
-// sendPush sends a message using the LINE Push API.
-func (c *LINEChannel) sendPush(ctx context.Context, to, content, quoteToken string) error {
-	payload := map[string]any{
-		"to":       to,
-		"messages": []map[string]string{buildTextMessage(content, quoteToken)},
-	}
-
-	return c.callAPI(ctx, linePushEndpoint, payload)
-}
-
-// sendLoading sends a loading animation indicator to the chat.
-func (c *LINEChannel) sendLoading(chatID string) {
-	payload := map[string]any{
-		"chatId":         chatID,
-		"loadingSeconds": 60,
-	}
-	if err := c.callAPI(c.ctx, lineLoadingEndpoint, payload); err != nil {
-		logger.DebugCF("line", "Failed to send loading indicator", map[string]any{
-			"error": err.Error(),
-		})
-	}
-}
-
-// callAPI makes an authenticated POST request to the LINE API.
-func (c *LINEChannel) callAPI(ctx context.Context, endpoint string, payload any) error {
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return fmt.Errorf("failed to marshal payload: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+c.config.ChannelAccessToken)
-
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("API request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		respBody, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("LINE API error (status %d): %s", resp.StatusCode, string(respBody))
-	}
-
-	return nil
-}
-
-// downloadContent downloads media content from the LINE API.
-func (c *LINEChannel) downloadContent(messageID, filename string) string {
-	url := fmt.Sprintf(lineContentEndpoint, messageID)
-	return utils.DownloadFile(url, filename, utils.DownloadOptions{
-		LoggerPrefix: "line",
-		ExtraHeaders: map[string]string{
-			"Authorization": "Bearer " + c.config.ChannelAccessToken,
-		},
-	})
-}
diff --git a/pkg/channels/maixcam.go b/pkg/channels/maixcam.go
deleted file mode 100644
index 34ce62b20..000000000
--- a/pkg/channels/maixcam.go
+++ /dev/null
@@ -1,243 +0,0 @@
-package channels
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net"
-	"sync"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-)
-
-type MaixCamChannel struct {
-	*BaseChannel
-	config     config.MaixCamConfig
-	listener   net.Listener
-	clients    map[net.Conn]bool
-	clientsMux sync.RWMutex
-}
-
-type MaixCamMessage struct {
-	Type      string         `json:"type"`
-	Tips      string         `json:"tips"`
-	Timestamp float64        `json:"timestamp"`
-	Data      map[string]any `json:"data"`
-}
-
-func NewMaixCamChannel(cfg config.MaixCamConfig, bus *bus.MessageBus) (*MaixCamChannel, error) {
-	base := NewBaseChannel("maixcam", cfg, bus, cfg.AllowFrom)
-
-	return &MaixCamChannel{
-		BaseChannel: base,
-		config:      cfg,
-		clients:     make(map[net.Conn]bool),
-	}, nil
-}
-
-func (c *MaixCamChannel) Start(ctx context.Context) error {
-	logger.InfoC("maixcam", "Starting MaixCam channel server")
-
-	addr := fmt.Sprintf("%s:%d", c.config.Host, c.config.Port)
-	listener, err := net.Listen("tcp", addr)
-	if err != nil {
-		return fmt.Errorf("failed to listen on %s: %w", addr, err)
-	}
-
-	c.listener = listener
-	c.setRunning(true)
-
-	logger.InfoCF("maixcam", "MaixCam server listening", map[string]any{
-		"host": c.config.Host,
-		"port": c.config.Port,
-	})
-
-	go c.acceptConnections(ctx)
-
-	return nil
-}
-
-func (c *MaixCamChannel) acceptConnections(ctx context.Context) {
-	logger.DebugC("maixcam", "Starting connection acceptor")
-
-	for {
-		select {
-		case <-ctx.Done():
-			logger.InfoC("maixcam", "Stopping connection acceptor")
-			return
-		default:
-			conn, err := c.listener.Accept()
-			if err != nil {
-				if c.running {
-					logger.ErrorCF("maixcam", "Failed to accept connection", map[string]any{
-						"error": err.Error(),
-					})
-				}
-				return
-			}
-
-			logger.InfoCF("maixcam", "New connection from MaixCam device", map[string]any{
-				"remote_addr": conn.RemoteAddr().String(),
-			})
-
-			c.clientsMux.Lock()
-			c.clients[conn] = true
-			c.clientsMux.Unlock()
-
-			go c.handleConnection(conn, ctx)
-		}
-	}
-}
-
-func (c *MaixCamChannel) handleConnection(conn net.Conn, ctx context.Context) {
-	logger.DebugC("maixcam", "Handling MaixCam connection")
-
-	defer func() {
-		conn.Close()
-		c.clientsMux.Lock()
-		delete(c.clients, conn)
-		c.clientsMux.Unlock()
-		logger.DebugC("maixcam", "Connection closed")
-	}()
-
-	decoder := json.NewDecoder(conn)
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			var msg MaixCamMessage
-			if err := decoder.Decode(&msg); err != nil {
-				if err.Error() != "EOF" {
-					logger.ErrorCF("maixcam", "Failed to decode message", map[string]any{
-						"error": err.Error(),
-					})
-				}
-				return
-			}
-
-			c.processMessage(msg, conn)
-		}
-	}
-}
-
-func (c *MaixCamChannel) processMessage(msg MaixCamMessage, conn net.Conn) {
-	switch msg.Type {
-	case "person_detected":
-		c.handlePersonDetection(msg)
-	case "heartbeat":
-		logger.DebugC("maixcam", "Received heartbeat")
-	case "status":
-		c.handleStatusUpdate(msg)
-	default:
-		logger.WarnCF("maixcam", "Unknown message type", map[string]any{
-			"type": msg.Type,
-		})
-	}
-}
-
-func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
-	logger.InfoCF("maixcam", "", map[string]any{
-		"timestamp": msg.Timestamp,
-		"data":      msg.Data,
-	})
-
-	senderID := "maixcam"
-	chatID := "default"
-
-	classInfo, ok := msg.Data["class_name"].(string)
-	if !ok {
-		classInfo = "person"
-	}
-
-	score, _ := msg.Data["score"].(float64)
-	x, _ := msg.Data["x"].(float64)
-	y, _ := msg.Data["y"].(float64)
-	w, _ := msg.Data["w"].(float64)
-	h, _ := msg.Data["h"].(float64)
-
-	content := fmt.Sprintf("📷 Person detected!\nClass: %s\nConfidence: %.2f%%\nPosition: (%.0f, %.0f)\nSize: %.0fx%.0f",
-		classInfo, score*100, x, y, w, h)
-
-	metadata := map[string]string{
-		"timestamp": fmt.Sprintf("%.0f", msg.Timestamp),
-		"class_id":  fmt.Sprintf("%.0f", msg.Data["class_id"]),
-		"score":     fmt.Sprintf("%.2f", score),
-		"x":         fmt.Sprintf("%.0f", x),
-		"y":         fmt.Sprintf("%.0f", y),
-		"w":         fmt.Sprintf("%.0f", w),
-		"h":         fmt.Sprintf("%.0f", h),
-		"peer_kind": "channel",
-		"peer_id":   "default",
-	}
-
-	c.HandleMessage(senderID, chatID, content, []string{}, metadata)
-}
-
-func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) {
-	logger.InfoCF("maixcam", "Status update from MaixCam", map[string]any{
-		"status": msg.Data,
-	})
-}
-
-func (c *MaixCamChannel) Stop(ctx context.Context) error {
-	logger.InfoC("maixcam", "Stopping MaixCam channel")
-	c.setRunning(false)
-
-	if c.listener != nil {
-		c.listener.Close()
-	}
-
-	c.clientsMux.Lock()
-	defer c.clientsMux.Unlock()
-
-	for conn := range c.clients {
-		conn.Close()
-	}
-	c.clients = make(map[net.Conn]bool)
-
-	logger.InfoC("maixcam", "MaixCam channel stopped")
-	return nil
-}
-
-func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("maixcam channel not running")
-	}
-
-	c.clientsMux.RLock()
-	defer c.clientsMux.RUnlock()
-
-	if len(c.clients) == 0 {
-		logger.WarnC("maixcam", "No MaixCam devices connected")
-		return fmt.Errorf("no connected MaixCam devices")
-	}
-
-	response := map[string]any{
-		"type":      "command",
-		"timestamp": float64(0),
-		"message":   msg.Content,
-		"chat_id":   msg.ChatID,
-	}
-
-	data, err := json.Marshal(response)
-	if err != nil {
-		return fmt.Errorf("failed to marshal response: %w", err)
-	}
-
-	var sendErr error
-	for conn := range c.clients {
-		if _, err := conn.Write(data); err != nil {
-			logger.ErrorCF("maixcam", "Failed to send to client", map[string]any{
-				"client": conn.RemoteAddr().String(),
-				"error":  err.Error(),
-			})
-			sendErr = err
-		}
-	}
-
-	return sendErr
-}
diff --git a/pkg/channels/onebot.go b/pkg/channels/onebot.go
deleted file mode 100644
index cee8ad9d3..000000000
--- a/pkg/channels/onebot.go
+++ /dev/null
@@ -1,982 +0,0 @@
-package channels
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/gorilla/websocket"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
-)
-
-type OneBotChannel struct {
-	*BaseChannel
-	config          config.OneBotConfig
-	conn            *websocket.Conn
-	ctx             context.Context
-	cancel          context.CancelFunc
-	dedup           map[string]struct{}
-	dedupRing       []string
-	dedupIdx        int
-	mu              sync.Mutex
-	writeMu         sync.Mutex
-	echoCounter     int64
-	selfID          int64
-	pending         map[string]chan json.RawMessage
-	pendingMu       sync.Mutex
-	transcriber     *voice.GroqTranscriber
-	lastMessageID   sync.Map
-	pendingEmojiMsg sync.Map
-}
-
-type oneBotRawEvent struct {
-	PostType      string          `json:"post_type"`
-	MessageType   string          `json:"message_type"`
-	SubType       string          `json:"sub_type"`
-	MessageID     json.RawMessage `json:"message_id"`
-	UserID        json.RawMessage `json:"user_id"`
-	GroupID       json.RawMessage `json:"group_id"`
-	RawMessage    string          `json:"raw_message"`
-	Message       json.RawMessage `json:"message"`
-	Sender        json.RawMessage `json:"sender"`
-	SelfID        json.RawMessage `json:"self_id"`
-	Time          json.RawMessage `json:"time"`
-	MetaEventType string          `json:"meta_event_type"`
-	NoticeType    string          `json:"notice_type"`
-	Echo          string          `json:"echo"`
-	RetCode       json.RawMessage `json:"retcode"`
-	Status        json.RawMessage `json:"status"`
-	Data          json.RawMessage `json:"data"`
-}
-
-type BotStatus struct {
-	Online bool `json:"online"`
-	Good   bool `json:"good"`
-}
-
-func isAPIResponse(raw json.RawMessage) bool {
-	if len(raw) == 0 {
-		return false
-	}
-	var s string
-	if json.Unmarshal(raw, &s) == nil {
-		return s == "ok" || s == "failed"
-	}
-	var bs BotStatus
-	if json.Unmarshal(raw, &bs) == nil {
-		return bs.Online || bs.Good
-	}
-	return false
-}
-
-type oneBotSender struct {
-	UserID   json.RawMessage `json:"user_id"`
-	Nickname string          `json:"nickname"`
-	Card     string          `json:"card"`
-}
-
-type oneBotAPIRequest struct {
-	Action string `json:"action"`
-	Params any    `json:"params"`
-	Echo   string `json:"echo,omitempty"`
-}
-
-type oneBotMessageSegment struct {
-	Type string         `json:"type"`
-	Data map[string]any `json:"data"`
-}
-
-func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*OneBotChannel, error) {
-	base := NewBaseChannel("onebot", cfg, messageBus, cfg.AllowFrom)
-
-	const dedupSize = 1024
-	return &OneBotChannel{
-		BaseChannel: base,
-		config:      cfg,
-		dedup:       make(map[string]struct{}, dedupSize),
-		dedupRing:   make([]string, dedupSize),
-		dedupIdx:    0,
-		pending:     make(map[string]chan json.RawMessage),
-	}, nil
-}
-
-func (c *OneBotChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
-func (c *OneBotChannel) setMsgEmojiLike(messageID string, emojiID int, set bool) {
-	go func() {
-		_, err := c.sendAPIRequest("set_msg_emoji_like", map[string]any{
-			"message_id": messageID,
-			"emoji_id":   emojiID,
-			"set":        set,
-		}, 5*time.Second)
-		if err != nil {
-			logger.DebugCF("onebot", "Failed to set emoji like", map[string]any{
-				"message_id": messageID,
-				"error":      err.Error(),
-			})
-		}
-	}()
-}
-
-func (c *OneBotChannel) Start(ctx context.Context) error {
-	if c.config.WSUrl == "" {
-		return fmt.Errorf("OneBot ws_url not configured")
-	}
-
-	logger.InfoCF("onebot", "Starting OneBot channel", map[string]any{
-		"ws_url": c.config.WSUrl,
-	})
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	if err := c.connect(); err != nil {
-		logger.WarnCF("onebot", "Initial connection failed, will retry in background", map[string]any{
-			"error": err.Error(),
-		})
-	} else {
-		go c.listen()
-		c.fetchSelfID()
-	}
-
-	if c.config.ReconnectInterval > 0 {
-		go c.reconnectLoop()
-	} else {
-		if c.conn == nil {
-			return fmt.Errorf("failed to connect to OneBot and reconnect is disabled")
-		}
-	}
-
-	c.setRunning(true)
-	logger.InfoC("onebot", "OneBot channel started successfully")
-
-	return nil
-}
-
-func (c *OneBotChannel) connect() error {
-	dialer := websocket.DefaultDialer
-	dialer.HandshakeTimeout = 10 * time.Second
-
-	header := make(map[string][]string)
-	if c.config.AccessToken != "" {
-		header["Authorization"] = []string{"Bearer " + c.config.AccessToken}
-	}
-
-	conn, _, err := dialer.Dial(c.config.WSUrl, header)
-	if err != nil {
-		return err
-	}
-
-	conn.SetPongHandler(func(appData string) error {
-		_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-		return nil
-	})
-	_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-
-	c.mu.Lock()
-	c.conn = conn
-	c.mu.Unlock()
-
-	go c.pinger(conn)
-
-	logger.InfoC("onebot", "WebSocket connected")
-	return nil
-}
-
-func (c *OneBotChannel) pinger(conn *websocket.Conn) {
-	ticker := time.NewTicker(30 * time.Second)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-c.ctx.Done():
-			return
-		case <-ticker.C:
-			c.writeMu.Lock()
-			err := conn.WriteMessage(websocket.PingMessage, nil)
-			c.writeMu.Unlock()
-			if err != nil {
-				logger.DebugCF("onebot", "Ping write failed, stopping pinger", map[string]any{
-					"error": err.Error(),
-				})
-				return
-			}
-		}
-	}
-}
-
-func (c *OneBotChannel) fetchSelfID() {
-	resp, err := c.sendAPIRequest("get_login_info", nil, 5*time.Second)
-	if err != nil {
-		logger.WarnCF("onebot", "Failed to get_login_info", map[string]any{
-			"error": err.Error(),
-		})
-		return
-	}
-
-	type loginInfo struct {
-		UserID   json.RawMessage `json:"user_id"`
-		Nickname string          `json:"nickname"`
-	}
-	for _, extract := range []func() (*loginInfo, error){
-		func() (*loginInfo, error) {
-			var w struct {
-				Data loginInfo `json:"data"`
-			}
-			err := json.Unmarshal(resp, &w)
-			return &w.Data, err
-		},
-		func() (*loginInfo, error) {
-			var f loginInfo
-			err := json.Unmarshal(resp, &f)
-			return &f, err
-		},
-	} {
-		info, err := extract()
-		if err != nil || len(info.UserID) == 0 {
-			continue
-		}
-		if uid, err := parseJSONInt64(info.UserID); err == nil && uid > 0 {
-			atomic.StoreInt64(&c.selfID, uid)
-			logger.InfoCF("onebot", "Bot self ID retrieved", map[string]any{
-				"self_id":  uid,
-				"nickname": info.Nickname,
-			})
-			return
-		}
-	}
-
-	logger.WarnCF("onebot", "Could not parse self ID from get_login_info response", map[string]any{
-		"response": string(resp),
-	})
-}
-
-func (c *OneBotChannel) sendAPIRequest(action string, params any, timeout time.Duration) (json.RawMessage, error) {
-	c.mu.Lock()
-	conn := c.conn
-	c.mu.Unlock()
-
-	if conn == nil {
-		return nil, fmt.Errorf("WebSocket not connected")
-	}
-
-	echo := fmt.Sprintf("api_%d_%d", time.Now().UnixNano(), atomic.AddInt64(&c.echoCounter, 1))
-
-	ch := make(chan json.RawMessage, 1)
-	c.pendingMu.Lock()
-	c.pending[echo] = ch
-	c.pendingMu.Unlock()
-
-	defer func() {
-		c.pendingMu.Lock()
-		delete(c.pending, echo)
-		c.pendingMu.Unlock()
-	}()
-
-	req := oneBotAPIRequest{
-		Action: action,
-		Params: params,
-		Echo:   echo,
-	}
-
-	data, err := json.Marshal(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal API request: %w", err)
-	}
-
-	c.writeMu.Lock()
-	err = conn.WriteMessage(websocket.TextMessage, data)
-	c.writeMu.Unlock()
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to write API request: %w", err)
-	}
-
-	select {
-	case resp := <-ch:
-		return resp, nil
-	case <-time.After(timeout):
-		return nil, fmt.Errorf("API request %s timed out after %v", action, timeout)
-	case <-c.ctx.Done():
-		return nil, fmt.Errorf("context cancelled")
-	}
-}
-
-func (c *OneBotChannel) reconnectLoop() {
-	interval := time.Duration(c.config.ReconnectInterval) * time.Second
-	if interval < 5*time.Second {
-		interval = 5 * time.Second
-	}
-
-	for {
-		select {
-		case <-c.ctx.Done():
-			return
-		case <-time.After(interval):
-			c.mu.Lock()
-			conn := c.conn
-			c.mu.Unlock()
-
-			if conn == nil {
-				logger.InfoC("onebot", "Attempting to reconnect...")
-				if err := c.connect(); err != nil {
-					logger.ErrorCF("onebot", "Reconnect failed", map[string]any{
-						"error": err.Error(),
-					})
-				} else {
-					go c.listen()
-					c.fetchSelfID()
-				}
-			}
-		}
-	}
-}
-
-func (c *OneBotChannel) Stop(ctx context.Context) error {
-	logger.InfoC("onebot", "Stopping OneBot channel")
-	c.setRunning(false)
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	c.pendingMu.Lock()
-	for echo, ch := range c.pending {
-		close(ch)
-		delete(c.pending, echo)
-	}
-	c.pendingMu.Unlock()
-
-	c.mu.Lock()
-	if c.conn != nil {
-		c.conn.Close()
-		c.conn = nil
-	}
-	c.mu.Unlock()
-
-	return nil
-}
-
-func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("OneBot channel not running")
-	}
-
-	c.mu.Lock()
-	conn := c.conn
-	c.mu.Unlock()
-
-	if conn == nil {
-		return fmt.Errorf("OneBot WebSocket not connected")
-	}
-
-	action, params, err := c.buildSendRequest(msg)
-	if err != nil {
-		return err
-	}
-
-	echo := fmt.Sprintf("send_%d", atomic.AddInt64(&c.echoCounter, 1))
-
-	req := oneBotAPIRequest{
-		Action: action,
-		Params: params,
-		Echo:   echo,
-	}
-
-	data, err := json.Marshal(req)
-	if err != nil {
-		return fmt.Errorf("failed to marshal OneBot request: %w", err)
-	}
-
-	c.writeMu.Lock()
-	err = conn.WriteMessage(websocket.TextMessage, data)
-	c.writeMu.Unlock()
-
-	if err != nil {
-		logger.ErrorCF("onebot", "Failed to send message", map[string]any{
-			"error": err.Error(),
-		})
-		return err
-	}
-
-	if msgID, ok := c.pendingEmojiMsg.LoadAndDelete(msg.ChatID); ok {
-		if mid, ok := msgID.(string); ok && mid != "" {
-			c.setMsgEmojiLike(mid, 289, false)
-		}
-	}
-
-	return nil
-}
-
-func (c *OneBotChannel) buildMessageSegments(chatID, content string) []oneBotMessageSegment {
-	var segments []oneBotMessageSegment
-
-	if lastMsgID, ok := c.lastMessageID.Load(chatID); ok {
-		if msgID, ok := lastMsgID.(string); ok && msgID != "" {
-			segments = append(segments, oneBotMessageSegment{
-				Type: "reply",
-				Data: map[string]any{"id": msgID},
-			})
-		}
-	}
-
-	segments = append(segments, oneBotMessageSegment{
-		Type: "text",
-		Data: map[string]any{"text": content},
-	})
-
-	return segments
-}
-
-func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, any, error) {
-	chatID := msg.ChatID
-	segments := c.buildMessageSegments(chatID, msg.Content)
-
-	var action, idKey string
-	var rawID string
-	if rest, ok := strings.CutPrefix(chatID, "group:"); ok {
-		action, idKey, rawID = "send_group_msg", "group_id", rest
-	} else if rest, ok := strings.CutPrefix(chatID, "private:"); ok {
-		action, idKey, rawID = "send_private_msg", "user_id", rest
-	} else {
-		action, idKey, rawID = "send_private_msg", "user_id", chatID
-	}
-
-	id, err := strconv.ParseInt(rawID, 10, 64)
-	if err != nil {
-		return "", nil, fmt.Errorf("invalid %s in chatID: %s", idKey, chatID)
-	}
-	return action, map[string]any{idKey: id, "message": segments}, nil
-}
-
-func (c *OneBotChannel) listen() {
-	c.mu.Lock()
-	conn := c.conn
-	c.mu.Unlock()
-
-	if conn == nil {
-		logger.WarnC("onebot", "WebSocket connection is nil, listener exiting")
-		return
-	}
-
-	for {
-		select {
-		case <-c.ctx.Done():
-			return
-		default:
-			_, message, err := conn.ReadMessage()
-			if err != nil {
-				logger.ErrorCF("onebot", "WebSocket read error", map[string]any{
-					"error": err.Error(),
-				})
-				c.mu.Lock()
-				if c.conn == conn {
-					c.conn.Close()
-					c.conn = nil
-				}
-				c.mu.Unlock()
-				return
-			}
-
-			_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-
-			var raw oneBotRawEvent
-			if err := json.Unmarshal(message, &raw); err != nil {
-				logger.WarnCF("onebot", "Failed to unmarshal raw event", map[string]any{
-					"error":   err.Error(),
-					"payload": string(message),
-				})
-				continue
-			}
-
-			logger.DebugCF("onebot", "WebSocket event", map[string]any{
-				"length":    len(message),
-				"post_type": raw.PostType,
-				"sub_type":  raw.SubType,
-			})
-
-			if raw.Echo != "" {
-				c.pendingMu.Lock()
-				ch, ok := c.pending[raw.Echo]
-				c.pendingMu.Unlock()
-
-				if ok {
-					select {
-					case ch <- message:
-					default:
-					}
-				} else {
-					logger.DebugCF("onebot", "Received API response (no waiter)", map[string]any{
-						"echo":   raw.Echo,
-						"status": string(raw.Status),
-					})
-				}
-				continue
-			}
-
-			if isAPIResponse(raw.Status) {
-				logger.DebugCF("onebot", "Received API response without echo, skipping", map[string]any{
-					"status": string(raw.Status),
-				})
-				continue
-			}
-
-			c.handleRawEvent(&raw)
-		}
-	}
-}
-
-func parseJSONInt64(raw json.RawMessage) (int64, error) {
-	if len(raw) == 0 {
-		return 0, nil
-	}
-
-	var n int64
-	if err := json.Unmarshal(raw, &n); err == nil {
-		return n, nil
-	}
-
-	var s string
-	if err := json.Unmarshal(raw, &s); err == nil {
-		return strconv.ParseInt(s, 10, 64)
-	}
-	return 0, fmt.Errorf("cannot parse as int64: %s", string(raw))
-}
-
-func parseJSONString(raw json.RawMessage) string {
-	if len(raw) == 0 {
-		return ""
-	}
-	var s string
-	if err := json.Unmarshal(raw, &s); err == nil {
-		return s
-	}
-
-	return string(raw)
-}
-
-type parseMessageResult struct {
-	Text           string
-	IsBotMentioned bool
-	Media          []string
-	LocalFiles     []string
-	ReplyTo        string
-}
-
-func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64) parseMessageResult {
-	if len(raw) == 0 {
-		return parseMessageResult{}
-	}
-
-	var s string
-	if err := json.Unmarshal(raw, &s); err == nil {
-		mentioned := false
-		if selfID > 0 {
-			cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
-			if strings.Contains(s, cqAt) {
-				mentioned = true
-				s = strings.ReplaceAll(s, cqAt, "")
-				s = strings.TrimSpace(s)
-			}
-		}
-		return parseMessageResult{Text: s, IsBotMentioned: mentioned}
-	}
-
-	var segments []map[string]any
-	if err := json.Unmarshal(raw, &segments); err != nil {
-		return parseMessageResult{}
-	}
-
-	var textParts []string
-	mentioned := false
-	selfIDStr := strconv.FormatInt(selfID, 10)
-	var media []string
-	var localFiles []string
-	var replyTo string
-
-	for _, seg := range segments {
-		segType, _ := seg["type"].(string)
-		data, _ := seg["data"].(map[string]any)
-
-		switch segType {
-		case "text":
-			if data != nil {
-				if t, ok := data["text"].(string); ok {
-					textParts = append(textParts, t)
-				}
-			}
-
-		case "at":
-			if data != nil && selfID > 0 {
-				qqVal := fmt.Sprintf("%v", data["qq"])
-				if qqVal == selfIDStr || qqVal == "all" {
-					mentioned = true
-				}
-			}
-
-		case "image", "video", "file":
-			if data != nil {
-				url, _ := data["url"].(string)
-				if url != "" {
-					defaults := map[string]string{"image": "image.jpg", "video": "video.mp4", "file": "file"}
-					filename := defaults[segType]
-					if f, ok := data["file"].(string); ok && f != "" {
-						filename = f
-					} else if n, ok := data["name"].(string); ok && n != "" {
-						filename = n
-					}
-					localPath := utils.DownloadFile(url, filename, utils.DownloadOptions{
-						LoggerPrefix: "onebot",
-					})
-					if localPath != "" {
-						media = append(media, localPath)
-						localFiles = append(localFiles, localPath)
-						textParts = append(textParts, fmt.Sprintf("[%s]", segType))
-					}
-				}
-			}
-
-		case "record":
-			if data != nil {
-				url, _ := data["url"].(string)
-				if url != "" {
-					localPath := utils.DownloadFile(url, "voice.amr", utils.DownloadOptions{
-						LoggerPrefix: "onebot",
-					})
-					if localPath != "" {
-						localFiles = append(localFiles, localPath)
-						if c.transcriber != nil && c.transcriber.IsAvailable() {
-							tctx, tcancel := context.WithTimeout(c.ctx, 30*time.Second)
-							result, err := c.transcriber.Transcribe(tctx, localPath)
-							tcancel()
-							if err != nil {
-								logger.WarnCF("onebot", "Voice transcription failed", map[string]any{
-									"error": err.Error(),
-								})
-								textParts = append(textParts, "[voice (transcription failed)]")
-								media = append(media, localPath)
-							} else {
-								textParts = append(textParts, fmt.Sprintf("[voice transcription: %s]", result.Text))
-							}
-						} else {
-							textParts = append(textParts, "[voice]")
-							media = append(media, localPath)
-						}
-					}
-				}
-			}
-
-		case "reply":
-			if data != nil {
-				if id, ok := data["id"]; ok {
-					replyTo = fmt.Sprintf("%v", id)
-				}
-			}
-
-		case "face":
-			if data != nil {
-				faceID, _ := data["id"]
-				textParts = append(textParts, fmt.Sprintf("[face:%v]", faceID))
-			}
-
-		case "forward":
-			textParts = append(textParts, "[forward message]")
-
-		default:
-
-		}
-	}
-
-	return parseMessageResult{
-		Text:           strings.TrimSpace(strings.Join(textParts, "")),
-		IsBotMentioned: mentioned,
-		Media:          media,
-		LocalFiles:     localFiles,
-		ReplyTo:        replyTo,
-	}
-}
-
-func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
-	switch raw.PostType {
-	case "message":
-		if userID, err := parseJSONInt64(raw.UserID); err == nil && userID > 0 {
-			if !c.IsAllowed(strconv.FormatInt(userID, 10)) {
-				logger.DebugCF("onebot", "Message rejected by allowlist", map[string]any{
-					"user_id": userID,
-				})
-				return
-			}
-		}
-		c.handleMessage(raw)
-
-	case "message_sent":
-		logger.DebugCF("onebot", "Bot sent message event", map[string]any{
-			"message_type": raw.MessageType,
-			"message_id":   parseJSONString(raw.MessageID),
-		})
-
-	case "meta_event":
-		c.handleMetaEvent(raw)
-
-	case "notice":
-		c.handleNoticeEvent(raw)
-
-	case "request":
-		logger.DebugCF("onebot", "Request event received", map[string]any{
-			"sub_type": raw.SubType,
-		})
-
-	case "":
-		logger.DebugCF("onebot", "Event with empty post_type (possibly API response)", map[string]any{
-			"echo":   raw.Echo,
-			"status": raw.Status,
-		})
-
-	default:
-		logger.DebugCF("onebot", "Unknown post_type", map[string]any{
-			"post_type": raw.PostType,
-		})
-	}
-}
-
-func (c *OneBotChannel) handleMetaEvent(raw *oneBotRawEvent) {
-	if raw.MetaEventType == "lifecycle" {
-		logger.InfoCF("onebot", "Lifecycle event", map[string]any{"sub_type": raw.SubType})
-	} else if raw.MetaEventType != "heartbeat" {
-		logger.DebugCF("onebot", "Meta event: "+raw.MetaEventType, nil)
-	}
-}
-
-func (c *OneBotChannel) handleNoticeEvent(raw *oneBotRawEvent) {
-	fields := map[string]any{
-		"notice_type": raw.NoticeType,
-		"sub_type":    raw.SubType,
-		"group_id":    parseJSONString(raw.GroupID),
-		"user_id":     parseJSONString(raw.UserID),
-		"message_id":  parseJSONString(raw.MessageID),
-	}
-	switch raw.NoticeType {
-	case "group_recall", "group_increase", "group_decrease",
-		"friend_add", "group_admin", "group_ban":
-		logger.InfoCF("onebot", "Notice: "+raw.NoticeType, fields)
-	default:
-		logger.DebugCF("onebot", "Notice: "+raw.NoticeType, fields)
-	}
-}
-
-func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
-	// Parse fields from raw event
-	userID, err := parseJSONInt64(raw.UserID)
-	if err != nil {
-		logger.WarnCF("onebot", "Failed to parse user_id", map[string]any{
-			"error": err.Error(),
-			"raw":   string(raw.UserID),
-		})
-		return
-	}
-
-	groupID, _ := parseJSONInt64(raw.GroupID)
-	selfID, _ := parseJSONInt64(raw.SelfID)
-	messageID := parseJSONString(raw.MessageID)
-
-	if selfID == 0 {
-		selfID = atomic.LoadInt64(&c.selfID)
-	}
-
-	parsed := c.parseMessageSegments(raw.Message, selfID)
-	isBotMentioned := parsed.IsBotMentioned
-
-	content := raw.RawMessage
-	if content == "" {
-		content = parsed.Text
-	} else if selfID > 0 {
-		cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
-		if strings.Contains(content, cqAt) {
-			isBotMentioned = true
-			content = strings.ReplaceAll(content, cqAt, "")
-			content = strings.TrimSpace(content)
-		}
-	}
-
-	if parsed.Text != "" && content != parsed.Text && (len(parsed.Media) > 0 || parsed.ReplyTo != "") {
-		content = parsed.Text
-	}
-
-	var sender oneBotSender
-	if len(raw.Sender) > 0 {
-		if err := json.Unmarshal(raw.Sender, &sender); err != nil {
-			logger.WarnCF("onebot", "Failed to parse sender", map[string]any{
-				"error":  err.Error(),
-				"sender": string(raw.Sender),
-			})
-		}
-	}
-
-	// Clean up temp files when done
-	if len(parsed.LocalFiles) > 0 {
-		defer func() {
-			for _, f := range parsed.LocalFiles {
-				if err := os.Remove(f); err != nil {
-					logger.DebugCF("onebot", "Failed to remove temp file", map[string]any{
-						"path":  f,
-						"error": err.Error(),
-					})
-				}
-			}
-		}()
-	}
-
-	if c.isDuplicate(messageID) {
-		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]any{
-			"message_id": messageID,
-		})
-		return
-	}
-
-	if content == "" {
-		logger.DebugCF("onebot", "Received empty message, ignoring", map[string]any{
-			"message_id": messageID,
-		})
-		return
-	}
-
-	senderID := strconv.FormatInt(userID, 10)
-	var chatID string
-
-	metadata := map[string]string{
-		"message_id": messageID,
-	}
-
-	if parsed.ReplyTo != "" {
-		metadata["reply_to_message_id"] = parsed.ReplyTo
-	}
-
-	switch raw.MessageType {
-	case "private":
-		chatID = "private:" + senderID
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
-
-	case "group":
-		groupIDStr := strconv.FormatInt(groupID, 10)
-		chatID = "group:" + groupIDStr
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = groupIDStr
-		metadata["group_id"] = groupIDStr
-
-		senderUserID, _ := parseJSONInt64(sender.UserID)
-		if senderUserID > 0 {
-			metadata["sender_user_id"] = strconv.FormatInt(senderUserID, 10)
-		}
-
-		if sender.Card != "" {
-			metadata["sender_name"] = sender.Card
-		} else if sender.Nickname != "" {
-			metadata["sender_name"] = sender.Nickname
-		}
-
-		triggered, strippedContent := c.checkGroupTrigger(content, isBotMentioned)
-		if !triggered {
-			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]any{
-				"sender":       senderID,
-				"group":        groupIDStr,
-				"is_mentioned": isBotMentioned,
-				"content":      truncate(content, 100),
-			})
-			return
-		}
-		content = strippedContent
-
-	default:
-		logger.WarnCF("onebot", "Unknown message type, cannot route", map[string]any{
-			"type":       raw.MessageType,
-			"message_id": messageID,
-			"user_id":    userID,
-		})
-		return
-	}
-
-	logger.InfoCF("onebot", "Received "+raw.MessageType+" message", map[string]any{
-		"sender":      senderID,
-		"chat_id":     chatID,
-		"message_id":  messageID,
-		"length":      len(content),
-		"content":     truncate(content, 100),
-		"media_count": len(parsed.Media),
-	})
-
-	if sender.Nickname != "" {
-		metadata["nickname"] = sender.Nickname
-	}
-
-	c.lastMessageID.Store(chatID, messageID)
-
-	if raw.MessageType == "group" && messageID != "" && messageID != "0" {
-		c.setMsgEmojiLike(messageID, 289, true)
-		c.pendingEmojiMsg.Store(chatID, messageID)
-	}
-
-	c.HandleMessage(senderID, chatID, content, parsed.Media, metadata)
-}
-
-func (c *OneBotChannel) isDuplicate(messageID string) bool {
-	if messageID == "" || messageID == "0" {
-		return false
-	}
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if _, exists := c.dedup[messageID]; exists {
-		return true
-	}
-
-	if old := c.dedupRing[c.dedupIdx]; old != "" {
-		delete(c.dedup, old)
-	}
-	c.dedupRing[c.dedupIdx] = messageID
-	c.dedup[messageID] = struct{}{}
-	c.dedupIdx = (c.dedupIdx + 1) % len(c.dedupRing)
-
-	return false
-}
-
-func truncate(s string, n int) string {
-	runes := []rune(s)
-	if len(runes) <= n {
-		return s
-	}
-	return string(runes[:n]) + "..."
-}
-
-func (c *OneBotChannel) checkGroupTrigger(
-	content string,
-	isBotMentioned bool,
-) (triggered bool, strippedContent string) {
-	if isBotMentioned {
-		return true, strings.TrimSpace(content)
-	}
-
-	for _, prefix := range c.config.GroupTriggerPrefix {
-		if prefix == "" {
-			continue
-		}
-		if strings.HasPrefix(content, prefix) {
-			return true, strings.TrimSpace(strings.TrimPrefix(content, prefix))
-		}
-	}
-
-	return false, content
-}
diff --git a/pkg/channels/qq.go b/pkg/channels/qq.go
deleted file mode 100644
index b10776db6..000000000
--- a/pkg/channels/qq.go
+++ /dev/null
@@ -1,247 +0,0 @@
-package channels
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/tencent-connect/botgo"
-	"github.com/tencent-connect/botgo/dto"
-	"github.com/tencent-connect/botgo/event"
-	"github.com/tencent-connect/botgo/openapi"
-	"github.com/tencent-connect/botgo/token"
-	"golang.org/x/oauth2"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-)
-
-type QQChannel struct {
-	*BaseChannel
-	config         config.QQConfig
-	api            openapi.OpenAPI
-	tokenSource    oauth2.TokenSource
-	ctx            context.Context
-	cancel         context.CancelFunc
-	sessionManager botgo.SessionManager
-	processedIDs   map[string]bool
-	mu             sync.RWMutex
-}
-
-func NewQQChannel(cfg config.QQConfig, messageBus *bus.MessageBus) (*QQChannel, error) {
-	base := NewBaseChannel("qq", cfg, messageBus, cfg.AllowFrom)
-
-	return &QQChannel{
-		BaseChannel:  base,
-		config:       cfg,
-		processedIDs: make(map[string]bool),
-	}, nil
-}
-
-func (c *QQChannel) Start(ctx context.Context) error {
-	if c.config.AppID == "" || c.config.AppSecret == "" {
-		return fmt.Errorf("QQ app_id and app_secret not configured")
-	}
-
-	logger.InfoC("qq", "Starting QQ bot (WebSocket mode)")
-
-	// create token source
-	credentials := &token.QQBotCredentials{
-		AppID:     c.config.AppID,
-		AppSecret: c.config.AppSecret,
-	}
-	c.tokenSource = token.NewQQBotTokenSource(credentials)
-
-	// create child context
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	// start auto-refresh token goroutine
-	if err := token.StartRefreshAccessToken(c.ctx, c.tokenSource); err != nil {
-		return fmt.Errorf("failed to start token refresh: %w", err)
-	}
-
-	// initialize OpenAPI client
-	c.api = botgo.NewOpenAPI(c.config.AppID, c.tokenSource).WithTimeout(5 * time.Second)
-
-	// register event handlers
-	intent := event.RegisterHandlers(
-		c.handleC2CMessage(),
-		c.handleGroupATMessage(),
-	)
-
-	// get WebSocket endpoint
-	wsInfo, err := c.api.WS(c.ctx, nil, "")
-	if err != nil {
-		return fmt.Errorf("failed to get websocket info: %w", err)
-	}
-
-	logger.InfoCF("qq", "Got WebSocket info", map[string]any{
-		"shards": wsInfo.Shards,
-	})
-
-	// create and save sessionManager
-	c.sessionManager = botgo.NewSessionManager()
-
-	// start WebSocket connection in goroutine to avoid blocking
-	go func() {
-		if err := c.sessionManager.Start(wsInfo, c.tokenSource, &intent); err != nil {
-			logger.ErrorCF("qq", "WebSocket session error", map[string]any{
-				"error": err.Error(),
-			})
-			c.setRunning(false)
-		}
-	}()
-
-	c.setRunning(true)
-	logger.InfoC("qq", "QQ bot started successfully")
-
-	return nil
-}
-
-func (c *QQChannel) Stop(ctx context.Context) error {
-	logger.InfoC("qq", "Stopping QQ bot")
-	c.setRunning(false)
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	return nil
-}
-
-func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("QQ bot not running")
-	}
-
-	// construct message
-	msgToCreate := &dto.MessageToCreate{
-		Content: msg.Content,
-	}
-
-	// send C2C message
-	_, err := c.api.PostC2CMessage(ctx, msg.ChatID, msgToCreate)
-	if err != nil {
-		logger.ErrorCF("qq", "Failed to send C2C message", map[string]any{
-			"error": err.Error(),
-		})
-		return err
-	}
-
-	return nil
-}
-
-// handleC2CMessage handles QQ private messages
-func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
-	return func(event *dto.WSPayload, data *dto.WSC2CMessageData) error {
-		// deduplication check
-		if c.isDuplicate(data.ID) {
-			return nil
-		}
-
-		// extract user info
-		var senderID string
-		if data.Author != nil && data.Author.ID != "" {
-			senderID = data.Author.ID
-		} else {
-			logger.WarnC("qq", "Received message with no sender ID")
-			return nil
-		}
-
-		// extract message content
-		content := data.Content
-		if content == "" {
-			logger.DebugC("qq", "Received empty message, ignoring")
-			return nil
-		}
-
-		logger.InfoCF("qq", "Received C2C message", map[string]any{
-			"sender": senderID,
-			"length": len(content),
-		})
-
-		// forward to message bus
-		metadata := map[string]string{
-			"message_id": data.ID,
-			"peer_kind":  "direct",
-			"peer_id":    senderID,
-		}
-
-		c.HandleMessage(senderID, senderID, content, []string{}, metadata)
-
-		return nil
-	}
-}
-
-// handleGroupATMessage handles group @messages
-func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
-	return func(event *dto.WSPayload, data *dto.WSGroupATMessageData) error {
-		// deduplication check
-		if c.isDuplicate(data.ID) {
-			return nil
-		}
-
-		// extract user info
-		var senderID string
-		if data.Author != nil && data.Author.ID != "" {
-			senderID = data.Author.ID
-		} else {
-			logger.WarnC("qq", "Received group message with no sender ID")
-			return nil
-		}
-
-		// extract message content (remove @bot part)
-		content := data.Content
-		if content == "" {
-			logger.DebugC("qq", "Received empty group message, ignoring")
-			return nil
-		}
-
-		logger.InfoCF("qq", "Received group AT message", map[string]any{
-			"sender": senderID,
-			"group":  data.GroupID,
-			"length": len(content),
-		})
-
-		// forward to message bus (use GroupID as ChatID)
-		metadata := map[string]string{
-			"message_id": data.ID,
-			"group_id":   data.GroupID,
-			"peer_kind":  "group",
-			"peer_id":    data.GroupID,
-		}
-
-		c.HandleMessage(senderID, data.GroupID, content, []string{}, metadata)
-
-		return nil
-	}
-}
-
-// isDuplicate checks if message is duplicate
-func (c *QQChannel) isDuplicate(messageID string) bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.processedIDs[messageID] {
-		return true
-	}
-
-	c.processedIDs[messageID] = true
-
-	// simple cleanup: limit map size
-	if len(c.processedIDs) > 10000 {
-		// clear half
-		count := 0
-		for id := range c.processedIDs {
-			if count >= 5000 {
-				break
-			}
-			delete(c.processedIDs, id)
-			count++
-		}
-	}
-
-	return false
-}
diff --git a/pkg/channels/slack.go b/pkg/channels/slack.go
deleted file mode 100644
index f087aa8da..000000000
--- a/pkg/channels/slack.go
+++ /dev/null
@@ -1,443 +0,0 @@
-package channels
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/slack-go/slack"
-	"github.com/slack-go/slack/slackevents"
-	"github.com/slack-go/slack/socketmode"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
-)
-
-type SlackChannel struct {
-	*BaseChannel
-	config       config.SlackConfig
-	api          *slack.Client
-	socketClient *socketmode.Client
-	botUserID    string
-	teamID       string
-	transcriber  *voice.GroqTranscriber
-	ctx          context.Context
-	cancel       context.CancelFunc
-	pendingAcks  sync.Map
-}
-
-type slackMessageRef struct {
-	ChannelID string
-	Timestamp string
-}
-
-func NewSlackChannel(cfg config.SlackConfig, messageBus *bus.MessageBus) (*SlackChannel, error) {
-	if cfg.BotToken == "" || cfg.AppToken == "" {
-		return nil, fmt.Errorf("slack bot_token and app_token are required")
-	}
-
-	api := slack.New(
-		cfg.BotToken,
-		slack.OptionAppLevelToken(cfg.AppToken),
-	)
-
-	socketClient := socketmode.New(api)
-
-	base := NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom)
-
-	return &SlackChannel{
-		BaseChannel:  base,
-		config:       cfg,
-		api:          api,
-		socketClient: socketClient,
-	}, nil
-}
-
-func (c *SlackChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
-func (c *SlackChannel) Start(ctx context.Context) error {
-	logger.InfoC("slack", "Starting Slack channel (Socket Mode)")
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	authResp, err := c.api.AuthTest()
-	if err != nil {
-		return fmt.Errorf("slack auth test failed: %w", err)
-	}
-	c.botUserID = authResp.UserID
-	c.teamID = authResp.TeamID
-
-	logger.InfoCF("slack", "Slack bot connected", map[string]any{
-		"bot_user_id": c.botUserID,
-		"team":        authResp.Team,
-	})
-
-	go c.eventLoop()
-
-	go func() {
-		if err := c.socketClient.RunContext(c.ctx); err != nil {
-			if c.ctx.Err() == nil {
-				logger.ErrorCF("slack", "Socket Mode connection error", map[string]any{
-					"error": err.Error(),
-				})
-			}
-		}
-	}()
-
-	c.setRunning(true)
-	logger.InfoC("slack", "Slack channel started (Socket Mode)")
-	return nil
-}
-
-func (c *SlackChannel) Stop(ctx context.Context) error {
-	logger.InfoC("slack", "Stopping Slack channel")
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	c.setRunning(false)
-	logger.InfoC("slack", "Slack channel stopped")
-	return nil
-}
-
-func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("slack channel not running")
-	}
-
-	channelID, threadTS := parseSlackChatID(msg.ChatID)
-	if channelID == "" {
-		return fmt.Errorf("invalid slack chat ID: %s", msg.ChatID)
-	}
-
-	opts := []slack.MsgOption{
-		slack.MsgOptionText(msg.Content, false),
-	}
-
-	if threadTS != "" {
-		opts = append(opts, slack.MsgOptionTS(threadTS))
-	}
-
-	_, _, err := c.api.PostMessageContext(ctx, channelID, opts...)
-	if err != nil {
-		return fmt.Errorf("failed to send slack message: %w", err)
-	}
-
-	if ref, ok := c.pendingAcks.LoadAndDelete(msg.ChatID); ok {
-		msgRef := ref.(slackMessageRef)
-		c.api.AddReaction("white_check_mark", slack.ItemRef{
-			Channel:   msgRef.ChannelID,
-			Timestamp: msgRef.Timestamp,
-		})
-	}
-
-	logger.DebugCF("slack", "Message sent", map[string]any{
-		"channel_id": channelID,
-		"thread_ts":  threadTS,
-	})
-
-	return nil
-}
-
-func (c *SlackChannel) eventLoop() {
-	for {
-		select {
-		case <-c.ctx.Done():
-			return
-		case event, ok := <-c.socketClient.Events:
-			if !ok {
-				return
-			}
-			switch event.Type {
-			case socketmode.EventTypeEventsAPI:
-				c.handleEventsAPI(event)
-			case socketmode.EventTypeSlashCommand:
-				c.handleSlashCommand(event)
-			case socketmode.EventTypeInteractive:
-				if event.Request != nil {
-					c.socketClient.Ack(*event.Request)
-				}
-			}
-		}
-	}
-}
-
-func (c *SlackChannel) handleEventsAPI(event socketmode.Event) {
-	if event.Request != nil {
-		c.socketClient.Ack(*event.Request)
-	}
-
-	eventsAPIEvent, ok := event.Data.(slackevents.EventsAPIEvent)
-	if !ok {
-		return
-	}
-
-	switch ev := eventsAPIEvent.InnerEvent.Data.(type) {
-	case *slackevents.MessageEvent:
-		c.handleMessageEvent(ev)
-	case *slackevents.AppMentionEvent:
-		c.handleAppMention(ev)
-	}
-}
-
-func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
-	if ev.User == c.botUserID || ev.User == "" {
-		return
-	}
-	if ev.BotID != "" {
-		return
-	}
-	if ev.SubType != "" && ev.SubType != "file_share" {
-		return
-	}
-
-	// check allowlist to avoid downloading attachments for rejected users
-	if !c.IsAllowed(ev.User) {
-		logger.DebugCF("slack", "Message rejected by allowlist", map[string]any{
-			"user_id": ev.User,
-		})
-		return
-	}
-
-	senderID := ev.User
-	channelID := ev.Channel
-	threadTS := ev.ThreadTimeStamp
-	messageTS := ev.TimeStamp
-
-	chatID := channelID
-	if threadTS != "" {
-		chatID = channelID + "/" + threadTS
-	}
-
-	c.api.AddReaction("eyes", slack.ItemRef{
-		Channel:   channelID,
-		Timestamp: messageTS,
-	})
-
-	c.pendingAcks.Store(chatID, slackMessageRef{
-		ChannelID: channelID,
-		Timestamp: messageTS,
-	})
-
-	content := ev.Text
-	content = c.stripBotMention(content)
-
-	var mediaPaths []string
-	localFiles := []string{} // track local files that need cleanup
-
-	// ensure temp files are cleaned up when function returns
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("slack", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
-			}
-		}
-	}()
-
-	if ev.Message != nil && len(ev.Message.Files) > 0 {
-		for _, file := range ev.Message.Files {
-			localPath := c.downloadSlackFile(file)
-			if localPath == "" {
-				continue
-			}
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
-
-			if utils.IsAudioFile(file.Name, file.Mimetype) && c.transcriber != nil && c.transcriber.IsAvailable() {
-				ctx, cancel := context.WithTimeout(c.ctx, 30*time.Second)
-				defer cancel()
-				result, err := c.transcriber.Transcribe(ctx, localPath)
-
-				if err != nil {
-					logger.ErrorCF("slack", "Voice transcription failed", map[string]any{"error": err.Error()})
-					content += fmt.Sprintf("\n[audio: %s (transcription failed)]", file.Name)
-				} else {
-					content += fmt.Sprintf("\n[voice transcription: %s]", result.Text)
-				}
-			} else {
-				content += fmt.Sprintf("\n[file: %s]", file.Name)
-			}
-		}
-	}
-
-	if strings.TrimSpace(content) == "" {
-		return
-	}
-
-	peerKind := "channel"
-	peerID := channelID
-	if strings.HasPrefix(channelID, "D") {
-		peerKind = "direct"
-		peerID = senderID
-	}
-
-	metadata := map[string]string{
-		"message_ts": messageTS,
-		"channel_id": channelID,
-		"thread_ts":  threadTS,
-		"platform":   "slack",
-		"peer_kind":  peerKind,
-		"peer_id":    peerID,
-		"team_id":    c.teamID,
-	}
-
-	logger.DebugCF("slack", "Received message", map[string]any{
-		"sender_id":  senderID,
-		"chat_id":    chatID,
-		"preview":    utils.Truncate(content, 50),
-		"has_thread": threadTS != "",
-	})
-
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
-}
-
-func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
-	if ev.User == c.botUserID {
-		return
-	}
-
-	if !c.IsAllowed(ev.User) {
-		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]any{
-			"user_id": ev.User,
-		})
-		return
-	}
-
-	senderID := ev.User
-	channelID := ev.Channel
-	threadTS := ev.ThreadTimeStamp
-	messageTS := ev.TimeStamp
-
-	var chatID string
-	if threadTS != "" {
-		chatID = channelID + "/" + threadTS
-	} else {
-		chatID = channelID + "/" + messageTS
-	}
-
-	c.api.AddReaction("eyes", slack.ItemRef{
-		Channel:   channelID,
-		Timestamp: messageTS,
-	})
-
-	c.pendingAcks.Store(chatID, slackMessageRef{
-		ChannelID: channelID,
-		Timestamp: messageTS,
-	})
-
-	content := c.stripBotMention(ev.Text)
-
-	if strings.TrimSpace(content) == "" {
-		return
-	}
-
-	mentionPeerKind := "channel"
-	mentionPeerID := channelID
-	if strings.HasPrefix(channelID, "D") {
-		mentionPeerKind = "direct"
-		mentionPeerID = senderID
-	}
-
-	metadata := map[string]string{
-		"message_ts": messageTS,
-		"channel_id": channelID,
-		"thread_ts":  threadTS,
-		"platform":   "slack",
-		"is_mention": "true",
-		"peer_kind":  mentionPeerKind,
-		"peer_id":    mentionPeerID,
-		"team_id":    c.teamID,
-	}
-
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-}
-
-func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
-	cmd, ok := event.Data.(slack.SlashCommand)
-	if !ok {
-		return
-	}
-
-	if event.Request != nil {
-		c.socketClient.Ack(*event.Request)
-	}
-
-	if !c.IsAllowed(cmd.UserID) {
-		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]any{
-			"user_id": cmd.UserID,
-		})
-		return
-	}
-
-	senderID := cmd.UserID
-	channelID := cmd.ChannelID
-	chatID := channelID
-	content := cmd.Text
-
-	if strings.TrimSpace(content) == "" {
-		content = "help"
-	}
-
-	metadata := map[string]string{
-		"channel_id": channelID,
-		"platform":   "slack",
-		"is_command": "true",
-		"trigger_id": cmd.TriggerID,
-		"peer_kind":  "channel",
-		"peer_id":    channelID,
-		"team_id":    c.teamID,
-	}
-
-	logger.DebugCF("slack", "Slash command received", map[string]any{
-		"sender_id": senderID,
-		"command":   cmd.Command,
-		"text":      utils.Truncate(content, 50),
-	})
-
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-}
-
-func (c *SlackChannel) downloadSlackFile(file slack.File) string {
-	downloadURL := file.URLPrivateDownload
-	if downloadURL == "" {
-		downloadURL = file.URLPrivate
-	}
-	if downloadURL == "" {
-		logger.ErrorCF("slack", "No download URL for file", map[string]any{"file_id": file.ID})
-		return ""
-	}
-
-	return utils.DownloadFile(downloadURL, file.Name, utils.DownloadOptions{
-		LoggerPrefix: "slack",
-		ExtraHeaders: map[string]string{
-			"Authorization": "Bearer " + c.config.BotToken,
-		},
-	})
-}
-
-func (c *SlackChannel) stripBotMention(text string) string {
-	mention := fmt.Sprintf("<@%s>", c.botUserID)
-	text = strings.ReplaceAll(text, mention, "")
-	return strings.TrimSpace(text)
-}
-
-func parseSlackChatID(chatID string) (channelID, threadTS string) {
-	parts := strings.SplitN(chatID, "/", 2)
-	channelID = parts[0]
-	if len(parts) > 1 {
-		threadTS = parts[1]
-	}
-	return
-}
diff --git a/pkg/channels/slack_test.go b/pkg/channels/slack_test.go
deleted file mode 100644
index 3707c2703..000000000
--- a/pkg/channels/slack_test.go
+++ /dev/null
@@ -1,174 +0,0 @@
-package channels
-
-import (
-	"testing"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func TestParseSlackChatID(t *testing.T) {
-	tests := []struct {
-		name       string
-		chatID     string
-		wantChanID string
-		wantThread string
-	}{
-		{
-			name:       "channel only",
-			chatID:     "C123456",
-			wantChanID: "C123456",
-			wantThread: "",
-		},
-		{
-			name:       "channel with thread",
-			chatID:     "C123456/1234567890.123456",
-			wantChanID: "C123456",
-			wantThread: "1234567890.123456",
-		},
-		{
-			name:       "DM channel",
-			chatID:     "D987654",
-			wantChanID: "D987654",
-			wantThread: "",
-		},
-		{
-			name:       "empty string",
-			chatID:     "",
-			wantChanID: "",
-			wantThread: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			chanID, threadTS := parseSlackChatID(tt.chatID)
-			if chanID != tt.wantChanID {
-				t.Errorf("parseSlackChatID(%q) channelID = %q, want %q", tt.chatID, chanID, tt.wantChanID)
-			}
-			if threadTS != tt.wantThread {
-				t.Errorf("parseSlackChatID(%q) threadTS = %q, want %q", tt.chatID, threadTS, tt.wantThread)
-			}
-		})
-	}
-}
-
-func TestStripBotMention(t *testing.T) {
-	ch := &SlackChannel{botUserID: "U12345BOT"}
-
-	tests := []struct {
-		name  string
-		input string
-		want  string
-	}{
-		{
-			name:  "mention at start",
-			input: "<@U12345BOT> hello there",
-			want:  "hello there",
-		},
-		{
-			name:  "mention in middle",
-			input: "hey <@U12345BOT> can you help",
-			want:  "hey  can you help",
-		},
-		{
-			name:  "no mention",
-			input: "hello world",
-			want:  "hello world",
-		},
-		{
-			name:  "empty string",
-			input: "",
-			want:  "",
-		},
-		{
-			name:  "only mention",
-			input: "<@U12345BOT>",
-			want:  "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := ch.stripBotMention(tt.input)
-			if got != tt.want {
-				t.Errorf("stripBotMention(%q) = %q, want %q", tt.input, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestNewSlackChannel(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("missing bot token", func(t *testing.T) {
-		cfg := config.SlackConfig{
-			BotToken: "",
-			AppToken: "xapp-test",
-		}
-		_, err := NewSlackChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing bot_token, got nil")
-		}
-	})
-
-	t.Run("missing app token", func(t *testing.T) {
-		cfg := config.SlackConfig{
-			BotToken: "xoxb-test",
-			AppToken: "",
-		}
-		_, err := NewSlackChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing app_token, got nil")
-		}
-	})
-
-	t.Run("valid config", func(t *testing.T) {
-		cfg := config.SlackConfig{
-			BotToken:  "xoxb-test",
-			AppToken:  "xapp-test",
-			AllowFrom: []string{"U123"},
-		}
-		ch, err := NewSlackChannel(cfg, msgBus)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if ch.Name() != "slack" {
-			t.Errorf("Name() = %q, want %q", ch.Name(), "slack")
-		}
-		if ch.IsRunning() {
-			t.Error("new channel should not be running")
-		}
-	})
-}
-
-func TestSlackChannelIsAllowed(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("empty allowlist allows all", func(t *testing.T) {
-		cfg := config.SlackConfig{
-			BotToken:  "xoxb-test",
-			AppToken:  "xapp-test",
-			AllowFrom: []string{},
-		}
-		ch, _ := NewSlackChannel(cfg, msgBus)
-		if !ch.IsAllowed("U_ANYONE") {
-			t.Error("empty allowlist should allow all users")
-		}
-	})
-
-	t.Run("allowlist restricts users", func(t *testing.T) {
-		cfg := config.SlackConfig{
-			BotToken:  "xoxb-test",
-			AppToken:  "xapp-test",
-			AllowFrom: []string{"U_ALLOWED"},
-		}
-		ch, _ := NewSlackChannel(cfg, msgBus)
-		if !ch.IsAllowed("U_ALLOWED") {
-			t.Error("allowed user should pass allowlist check")
-		}
-		if ch.IsAllowed("U_BLOCKED") {
-			t.Error("non-allowed user should be blocked")
-		}
-	})
-}
diff --git a/pkg/channels/telegram.go b/pkg/channels/telegram.go
deleted file mode 100644
index 5cd51e8bc..000000000
--- a/pkg/channels/telegram.go
+++ /dev/null
@@ -1,529 +0,0 @@
-package channels
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/url"
-	"os"
-	"regexp"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/mymmrac/telego"
-	"github.com/mymmrac/telego/telegohandler"
-	th "github.com/mymmrac/telego/telegohandler"
-	tu "github.com/mymmrac/telego/telegoutil"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
-)
-
-type TelegramChannel struct {
-	*BaseChannel
-	bot          *telego.Bot
-	commands     TelegramCommander
-	config       *config.Config
-	chatIDs      map[string]int64
-	transcriber  *voice.GroqTranscriber
-	placeholders sync.Map // chatID -> messageID
-	stopThinking sync.Map // chatID -> thinkingCancel
-}
-
-type thinkingCancel struct {
-	fn context.CancelFunc
-}
-
-func (c *thinkingCancel) Cancel() {
-	if c != nil && c.fn != nil {
-		c.fn()
-	}
-}
-
-func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChannel, error) {
-	var opts []telego.BotOption
-	telegramCfg := cfg.Channels.Telegram
-
-	if telegramCfg.Proxy != "" {
-		proxyURL, parseErr := url.Parse(telegramCfg.Proxy)
-		if parseErr != nil {
-			return nil, fmt.Errorf("invalid proxy URL %q: %w", telegramCfg.Proxy, parseErr)
-		}
-		opts = append(opts, telego.WithHTTPClient(&http.Client{
-			Transport: &http.Transport{
-				Proxy: http.ProxyURL(proxyURL),
-			},
-		}))
-	} else if os.Getenv("HTTP_PROXY") != "" || os.Getenv("HTTPS_PROXY") != "" {
-		// Use environment proxy if configured
-		opts = append(opts, telego.WithHTTPClient(&http.Client{
-			Transport: &http.Transport{
-				Proxy: http.ProxyFromEnvironment,
-			},
-		}))
-	}
-
-	bot, err := telego.NewBot(telegramCfg.Token, opts...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create telegram bot: %w", err)
-	}
-
-	base := NewBaseChannel("telegram", telegramCfg, bus, telegramCfg.AllowFrom)
-
-	return &TelegramChannel{
-		BaseChannel:  base,
-		commands:     NewTelegramCommands(bot, cfg),
-		bot:          bot,
-		config:       cfg,
-		chatIDs:      make(map[string]int64),
-		transcriber:  nil,
-		placeholders: sync.Map{},
-		stopThinking: sync.Map{},
-	}, nil
-}
-
-func (c *TelegramChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
-func (c *TelegramChannel) Start(ctx context.Context) error {
-	logger.InfoC("telegram", "Starting Telegram bot (polling mode)...")
-
-	updates, err := c.bot.UpdatesViaLongPolling(ctx, &telego.GetUpdatesParams{
-		Timeout: 30,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to start long polling: %w", err)
-	}
-
-	bh, err := telegohandler.NewBotHandler(c.bot, updates)
-	if err != nil {
-		return fmt.Errorf("failed to create bot handler: %w", err)
-	}
-
-	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
-		c.commands.Help(ctx, message)
-		return nil
-	}, th.CommandEqual("help"))
-	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
-		return c.commands.Start(ctx, message)
-	}, th.CommandEqual("start"))
-
-	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
-		return c.commands.Show(ctx, message)
-	}, th.CommandEqual("show"))
-
-	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
-		return c.commands.List(ctx, message)
-	}, th.CommandEqual("list"))
-
-	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
-		return c.handleMessage(ctx, &message)
-	}, th.AnyMessage())
-
-	c.setRunning(true)
-	logger.InfoCF("telegram", "Telegram bot connected", map[string]any{
-		"username": c.bot.Username(),
-	})
-
-	go bh.Start()
-
-	go func() {
-		<-ctx.Done()
-		bh.Stop()
-	}()
-
-	return nil
-}
-
-func (c *TelegramChannel) Stop(ctx context.Context) error {
-	logger.InfoC("telegram", "Stopping Telegram bot...")
-	c.setRunning(false)
-	return nil
-}
-
-func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("telegram bot not running")
-	}
-
-	chatID, err := parseChatID(msg.ChatID)
-	if err != nil {
-		return fmt.Errorf("invalid chat ID: %w", err)
-	}
-
-	// Stop thinking animation
-	if stop, ok := c.stopThinking.Load(msg.ChatID); ok {
-		if cf, ok := stop.(*thinkingCancel); ok && cf != nil {
-			cf.Cancel()
-		}
-		c.stopThinking.Delete(msg.ChatID)
-	}
-
-	htmlContent := markdownToTelegramHTML(msg.Content)
-
-	// Try to edit placeholder
-	if pID, ok := c.placeholders.Load(msg.ChatID); ok {
-		c.placeholders.Delete(msg.ChatID)
-		editMsg := tu.EditMessageText(tu.ID(chatID), pID.(int), htmlContent)
-		editMsg.ParseMode = telego.ModeHTML
-
-		if _, err = c.bot.EditMessageText(ctx, editMsg); err == nil {
-			return nil
-		}
-		// Fallback to new message if edit fails
-	}
-
-	tgMsg := tu.Message(tu.ID(chatID), htmlContent)
-	tgMsg.ParseMode = telego.ModeHTML
-
-	if _, err = c.bot.SendMessage(ctx, tgMsg); err != nil {
-		logger.ErrorCF("telegram", "HTML parse failed, falling back to plain text", map[string]any{
-			"error": err.Error(),
-		})
-		tgMsg.ParseMode = ""
-		_, err = c.bot.SendMessage(ctx, tgMsg)
-		return err
-	}
-
-	return nil
-}
-
-func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Message) error {
-	if message == nil {
-		return fmt.Errorf("message is nil")
-	}
-
-	user := message.From
-	if user == nil {
-		return fmt.Errorf("message sender (user) is nil")
-	}
-
-	senderID := fmt.Sprintf("%d", user.ID)
-	if user.Username != "" {
-		senderID = fmt.Sprintf("%d|%s", user.ID, user.Username)
-	}
-
-	// check allowlist to avoid downloading attachments for rejected users
-	if !c.IsAllowed(senderID) {
-		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]any{
-			"user_id": senderID,
-		})
-		return nil
-	}
-
-	chatID := message.Chat.ID
-	c.chatIDs[senderID] = chatID
-
-	content := ""
-	mediaPaths := []string{}
-	localFiles := []string{} // track local files that need cleanup
-
-	// ensure temp files are cleaned up when function returns
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("telegram", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
-			}
-		}
-	}()
-
-	if message.Text != "" {
-		content += message.Text
-	}
-
-	if message.Caption != "" {
-		if content != "" {
-			content += "\n"
-		}
-		content += message.Caption
-	}
-
-	if len(message.Photo) > 0 {
-		photo := message.Photo[len(message.Photo)-1]
-		photoPath := c.downloadPhoto(ctx, photo.FileID)
-		if photoPath != "" {
-			localFiles = append(localFiles, photoPath)
-			mediaPaths = append(mediaPaths, photoPath)
-			if content != "" {
-				content += "\n"
-			}
-			content += "[image: photo]"
-		}
-	}
-
-	if message.Voice != nil {
-		voicePath := c.downloadFile(ctx, message.Voice.FileID, ".ogg")
-		if voicePath != "" {
-			localFiles = append(localFiles, voicePath)
-			mediaPaths = append(mediaPaths, voicePath)
-
-			transcribedText := ""
-			if c.transcriber != nil && c.transcriber.IsAvailable() {
-				transcriberCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
-				defer cancel()
-
-				result, err := c.transcriber.Transcribe(transcriberCtx, voicePath)
-				if err != nil {
-					logger.ErrorCF("telegram", "Voice transcription failed", map[string]any{
-						"error": err.Error(),
-						"path":  voicePath,
-					})
-					transcribedText = "[voice (transcription failed)]"
-				} else {
-					transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
-					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]any{
-						"text": result.Text,
-					})
-				}
-			} else {
-				transcribedText = "[voice]"
-			}
-
-			if content != "" {
-				content += "\n"
-			}
-			content += transcribedText
-		}
-	}
-
-	if message.Audio != nil {
-		audioPath := c.downloadFile(ctx, message.Audio.FileID, ".mp3")
-		if audioPath != "" {
-			localFiles = append(localFiles, audioPath)
-			mediaPaths = append(mediaPaths, audioPath)
-			if content != "" {
-				content += "\n"
-			}
-			content += "[audio]"
-		}
-	}
-
-	if message.Document != nil {
-		docPath := c.downloadFile(ctx, message.Document.FileID, "")
-		if docPath != "" {
-			localFiles = append(localFiles, docPath)
-			mediaPaths = append(mediaPaths, docPath)
-			if content != "" {
-				content += "\n"
-			}
-			content += "[file]"
-		}
-	}
-
-	if content == "" {
-		content = "[empty message]"
-	}
-
-	logger.DebugCF("telegram", "Received message", map[string]any{
-		"sender_id": senderID,
-		"chat_id":   fmt.Sprintf("%d", chatID),
-		"preview":   utils.Truncate(content, 50),
-	})
-
-	// Thinking indicator
-	err := c.bot.SendChatAction(ctx, tu.ChatAction(tu.ID(chatID), telego.ChatActionTyping))
-	if err != nil {
-		logger.ErrorCF("telegram", "Failed to send chat action", map[string]any{
-			"error": err.Error(),
-		})
-	}
-
-	// Stop any previous thinking animation
-	chatIDStr := fmt.Sprintf("%d", chatID)
-	if prevStop, ok := c.stopThinking.Load(chatIDStr); ok {
-		if cf, ok := prevStop.(*thinkingCancel); ok && cf != nil {
-			cf.Cancel()
-		}
-	}
-
-	// Create cancel function for thinking state
-	_, thinkCancel := context.WithTimeout(ctx, 5*time.Minute)
-	c.stopThinking.Store(chatIDStr, &thinkingCancel{fn: thinkCancel})
-
-	pMsg, err := c.bot.SendMessage(ctx, tu.Message(tu.ID(chatID), "Thinking... 💭"))
-	if err == nil {
-		pID := pMsg.MessageID
-		c.placeholders.Store(chatIDStr, pID)
-	}
-
-	peerKind := "direct"
-	peerID := fmt.Sprintf("%d", user.ID)
-	if message.Chat.Type != "private" {
-		peerKind = "group"
-		peerID = fmt.Sprintf("%d", chatID)
-	}
-
-	metadata := map[string]string{
-		"message_id": fmt.Sprintf("%d", message.MessageID),
-		"user_id":    fmt.Sprintf("%d", user.ID),
-		"username":   user.Username,
-		"first_name": user.FirstName,
-		"is_group":   fmt.Sprintf("%t", message.Chat.Type != "private"),
-		"peer_kind":  peerKind,
-		"peer_id":    peerID,
-	}
-
-	c.HandleMessage(fmt.Sprintf("%d", user.ID), fmt.Sprintf("%d", chatID), content, mediaPaths, metadata)
-	return nil
-}
-
-func (c *TelegramChannel) downloadPhoto(ctx context.Context, fileID string) string {
-	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
-	if err != nil {
-		logger.ErrorCF("telegram", "Failed to get photo file", map[string]any{
-			"error": err.Error(),
-		})
-		return ""
-	}
-
-	return c.downloadFileWithInfo(file, ".jpg")
-}
-
-func (c *TelegramChannel) downloadFileWithInfo(file *telego.File, ext string) string {
-	if file.FilePath == "" {
-		return ""
-	}
-
-	url := c.bot.FileDownloadURL(file.FilePath)
-	logger.DebugCF("telegram", "File URL", map[string]any{"url": url})
-
-	// Use FilePath as filename for better identification
-	filename := file.FilePath + ext
-	return utils.DownloadFile(url, filename, utils.DownloadOptions{
-		LoggerPrefix: "telegram",
-	})
-}
-
-func (c *TelegramChannel) downloadFile(ctx context.Context, fileID, ext string) string {
-	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
-	if err != nil {
-		logger.ErrorCF("telegram", "Failed to get file", map[string]any{
-			"error": err.Error(),
-		})
-		return ""
-	}
-
-	return c.downloadFileWithInfo(file, ext)
-}
-
-func parseChatID(chatIDStr string) (int64, error) {
-	var id int64
-	_, err := fmt.Sscanf(chatIDStr, "%d", &id)
-	return id, err
-}
-
-func markdownToTelegramHTML(text string) string {
-	if text == "" {
-		return ""
-	}
-
-	codeBlocks := extractCodeBlocks(text)
-	text = codeBlocks.text
-
-	inlineCodes := extractInlineCodes(text)
-	text = inlineCodes.text
-
-	text = regexp.MustCompile(`^#{1,6}\s+(.+)$`).ReplaceAllString(text, "$1")
-
-	text = regexp.MustCompile(`^>\s*(.*)$`).ReplaceAllString(text, "$1")
-
-	text = escapeHTML(text)
-
-	text = regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`).ReplaceAllString(text, `<a href="$2">$1</a>`)
-
-	text = regexp.MustCompile(`\*\*(.+?)\*\*`).ReplaceAllString(text, "<b>$1</b>")
-
-	text = regexp.MustCompile(`__(.+?)__`).ReplaceAllString(text, "<b>$1</b>")
-
-	reItalic := regexp.MustCompile(`_([^_]+)_`)
-	text = reItalic.ReplaceAllStringFunc(text, func(s string) string {
-		match := reItalic.FindStringSubmatch(s)
-		if len(match) < 2 {
-			return s
-		}
-		return "<i>" + match[1] + "</i>"
-	})
-
-	text = regexp.MustCompile(`~~(.+?)~~`).ReplaceAllString(text, "<s>$1</s>")
-
-	text = regexp.MustCompile(`^[-*]\s+`).ReplaceAllString(text, "• ")
-
-	for i, code := range inlineCodes.codes {
-		escaped := escapeHTML(code)
-		text = strings.ReplaceAll(text, fmt.Sprintf("\x00IC%d\x00", i), fmt.Sprintf("<code>%s</code>", escaped))
-	}
-
-	for i, code := range codeBlocks.codes {
-		escaped := escapeHTML(code)
-		text = strings.ReplaceAll(
-			text,
-			fmt.Sprintf("\x00CB%d\x00", i),
-			fmt.Sprintf("<pre><code>%s</code></pre>", escaped),
-		)
-	}
-
-	return text
-}
-
-type codeBlockMatch struct {
-	text  string
-	codes []string
-}
-
-func extractCodeBlocks(text string) codeBlockMatch {
-	re := regexp.MustCompile("```[\\w]*\\n?([\\s\\S]*?)```")
-	matches := re.FindAllStringSubmatch(text, -1)
-
-	codes := make([]string, 0, len(matches))
-	for _, match := range matches {
-		codes = append(codes, match[1])
-	}
-
-	i := 0
-	text = re.ReplaceAllStringFunc(text, func(m string) string {
-		placeholder := fmt.Sprintf("\x00CB%d\x00", i)
-		i++
-		return placeholder
-	})
-
-	return codeBlockMatch{text: text, codes: codes}
-}
-
-type inlineCodeMatch struct {
-	text  string
-	codes []string
-}
-
-func extractInlineCodes(text string) inlineCodeMatch {
-	re := regexp.MustCompile("`([^`]+)`")
-	matches := re.FindAllStringSubmatch(text, -1)
-
-	codes := make([]string, 0, len(matches))
-	for _, match := range matches {
-		codes = append(codes, match[1])
-	}
-
-	i := 0
-	text = re.ReplaceAllStringFunc(text, func(m string) string {
-		placeholder := fmt.Sprintf("\x00IC%d\x00", i)
-		i++
-		return placeholder
-	})
-
-	return inlineCodeMatch{text: text, codes: codes}
-}
-
-func escapeHTML(text string) string {
-	text = strings.ReplaceAll(text, "&", "&amp;")
-	text = strings.ReplaceAll(text, "<", "&lt;")
-	text = strings.ReplaceAll(text, ">", "&gt;")
-	return text
-}
diff --git a/pkg/channels/telegram_commands.go b/pkg/channels/telegram_commands.go
deleted file mode 100644
index a084b641b..000000000
--- a/pkg/channels/telegram_commands.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package channels
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/mymmrac/telego"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-type TelegramCommander interface {
-	Help(ctx context.Context, message telego.Message) error
-	Start(ctx context.Context, message telego.Message) error
-	Show(ctx context.Context, message telego.Message) error
-	List(ctx context.Context, message telego.Message) error
-}
-
-type cmd struct {
-	bot    *telego.Bot
-	config *config.Config
-}
-
-func NewTelegramCommands(bot *telego.Bot, cfg *config.Config) TelegramCommander {
-	return &cmd{
-		bot:    bot,
-		config: cfg,
-	}
-}
-
-func commandArgs(text string) string {
-	parts := strings.SplitN(text, " ", 2)
-	if len(parts) < 2 {
-		return ""
-	}
-	return strings.TrimSpace(parts[1])
-}
-
-func (c *cmd) Help(ctx context.Context, message telego.Message) error {
-	msg := `/start - Start the bot
-/help - Show this help message
-/show [model|channel] - Show current configuration
-/list [models|channels] - List available options
-	`
-	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-		ChatID: telego.ChatID{ID: message.Chat.ID},
-		Text:   msg,
-		ReplyParameters: &telego.ReplyParameters{
-			MessageID: message.MessageID,
-		},
-	})
-	return err
-}
-
-func (c *cmd) Start(ctx context.Context, message telego.Message) error {
-	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-		ChatID: telego.ChatID{ID: message.Chat.ID},
-		Text:   "Hello! I am PicoClaw 🦞",
-		ReplyParameters: &telego.ReplyParameters{
-			MessageID: message.MessageID,
-		},
-	})
-	return err
-}
-
-func (c *cmd) Show(ctx context.Context, message telego.Message) error {
-	args := commandArgs(message.Text)
-	if args == "" {
-		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-			ChatID: telego.ChatID{ID: message.Chat.ID},
-			Text:   "Usage: /show [model|channel]",
-			ReplyParameters: &telego.ReplyParameters{
-				MessageID: message.MessageID,
-			},
-		})
-		return err
-	}
-
-	var response string
-	switch args {
-	case "model":
-		response = fmt.Sprintf("Current Model: %s (Provider: %s)",
-			c.config.Agents.Defaults.Model,
-			c.config.Agents.Defaults.Provider)
-	case "channel":
-		response = "Current Channel: telegram"
-	default:
-		response = fmt.Sprintf("Unknown parameter: %s. Try 'model' or 'channel'.", args)
-	}
-
-	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-		ChatID: telego.ChatID{ID: message.Chat.ID},
-		Text:   response,
-		ReplyParameters: &telego.ReplyParameters{
-			MessageID: message.MessageID,
-		},
-	})
-	return err
-}
-
-func (c *cmd) List(ctx context.Context, message telego.Message) error {
-	args := commandArgs(message.Text)
-	if args == "" {
-		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-			ChatID: telego.ChatID{ID: message.Chat.ID},
-			Text:   "Usage: /list [models|channels]",
-			ReplyParameters: &telego.ReplyParameters{
-				MessageID: message.MessageID,
-			},
-		})
-		return err
-	}
-
-	var response string
-	switch args {
-	case "models":
-		provider := c.config.Agents.Defaults.Provider
-		if provider == "" {
-			provider = "configured default"
-		}
-		response = fmt.Sprintf("Configured Model: %s\nProvider: %s\n\nTo change models, update config.yaml",
-			c.config.Agents.Defaults.Model, provider)
-
-	case "channels":
-		var enabled []string
-		if c.config.Channels.Telegram.Enabled {
-			enabled = append(enabled, "telegram")
-		}
-		if c.config.Channels.WhatsApp.Enabled {
-			enabled = append(enabled, "whatsapp")
-		}
-		if c.config.Channels.Feishu.Enabled {
-			enabled = append(enabled, "feishu")
-		}
-		if c.config.Channels.Discord.Enabled {
-			enabled = append(enabled, "discord")
-		}
-		if c.config.Channels.Slack.Enabled {
-			enabled = append(enabled, "slack")
-		}
-		response = fmt.Sprintf("Enabled Channels:\n- %s", strings.Join(enabled, "\n- "))
-
-	default:
-		response = fmt.Sprintf("Unknown parameter: %s. Try 'models' or 'channels'.", args)
-	}
-
-	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
-		ChatID: telego.ChatID{ID: message.Chat.ID},
-		Text:   response,
-		ReplyParameters: &telego.ReplyParameters{
-			MessageID: message.MessageID,
-		},
-	})
-	return err
-}
diff --git a/pkg/channels/wecom.go b/pkg/channels/wecom.go
deleted file mode 100644
index f8daf89de..000000000
--- a/pkg/channels/wecom.go
+++ /dev/null
@@ -1,605 +0,0 @@
-// PicoClaw - Ultra-lightweight personal AI agent
-// WeCom Bot (企业微信智能机器人) channel implementation
-// Uses webhook callback mode for receiving messages and webhook API for sending replies
-
-package channels
-
-import (
-	"bytes"
-	"context"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/sha1"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"net/http"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-// WeComBotChannel implements the Channel interface for WeCom Bot (企业微信智能机器人)
-// Uses webhook callback mode - simpler than WeCom App but only supports passive replies
-type WeComBotChannel struct {
-	*BaseChannel
-	config        config.WeComConfig
-	server        *http.Server
-	ctx           context.Context
-	cancel        context.CancelFunc
-	processedMsgs map[string]bool // Message deduplication: msg_id -> processed
-	msgMu         sync.RWMutex
-}
-
-// WeComBotMessage represents the JSON message structure from WeCom Bot (AIBOT)
-type WeComBotMessage struct {
-	MsgID    string `json:"msgid"`
-	AIBotID  string `json:"aibotid"`
-	ChatID   string `json:"chatid"`   // Session ID, only present for group chats
-	ChatType string `json:"chattype"` // "single" for DM, "group" for group chat
-	From     struct {
-		UserID string `json:"userid"`
-	} `json:"from"`
-	ResponseURL string `json:"response_url"`
-	MsgType     string `json:"msgtype"` // text, image, voice, file, mixed
-	Text        struct {
-		Content string `json:"content"`
-	} `json:"text"`
-	Image struct {
-		URL string `json:"url"`
-	} `json:"image"`
-	Voice struct {
-		Content string `json:"content"` // Voice to text content
-	} `json:"voice"`
-	File struct {
-		URL string `json:"url"`
-	} `json:"file"`
-	Mixed struct {
-		MsgItem []struct {
-			MsgType string `json:"msgtype"`
-			Text    struct {
-				Content string `json:"content"`
-			} `json:"text"`
-			Image struct {
-				URL string `json:"url"`
-			} `json:"image"`
-		} `json:"msg_item"`
-	} `json:"mixed"`
-	Quote struct {
-		MsgType string `json:"msgtype"`
-		Text    struct {
-			Content string `json:"content"`
-		} `json:"text"`
-	} `json:"quote"`
-}
-
-// WeComBotReplyMessage represents the reply message structure
-type WeComBotReplyMessage struct {
-	MsgType string `json:"msgtype"`
-	Text    struct {
-		Content string `json:"content"`
-	} `json:"text,omitempty"`
-}
-
-// NewWeComBotChannel creates a new WeCom Bot channel instance
-func NewWeComBotChannel(cfg config.WeComConfig, messageBus *bus.MessageBus) (*WeComBotChannel, error) {
-	if cfg.Token == "" || cfg.WebhookURL == "" {
-		return nil, fmt.Errorf("wecom token and webhook_url are required")
-	}
-
-	base := NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom)
-
-	return &WeComBotChannel{
-		BaseChannel:   base,
-		config:        cfg,
-		processedMsgs: make(map[string]bool),
-	}, nil
-}
-
-// Name returns the channel name
-func (c *WeComBotChannel) Name() string {
-	return "wecom"
-}
-
-// Start initializes the WeCom Bot channel with HTTP webhook server
-func (c *WeComBotChannel) Start(ctx context.Context) error {
-	logger.InfoC("wecom", "Starting WeCom Bot channel...")
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	// Setup HTTP server for webhook
-	mux := http.NewServeMux()
-	webhookPath := c.config.WebhookPath
-	if webhookPath == "" {
-		webhookPath = "/webhook/wecom"
-	}
-	mux.HandleFunc(webhookPath, c.handleWebhook)
-
-	// Health check endpoint
-	mux.HandleFunc("/health/wecom", c.handleHealth)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.server = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
-	c.setRunning(true)
-	logger.InfoCF("wecom", "WeCom Bot channel started", map[string]any{
-		"address": addr,
-		"path":    webhookPath,
-	})
-
-	// Start server in goroutine
-	go func() {
-		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom", "HTTP server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
-
-	return nil
-}
-
-// Stop gracefully stops the WeCom Bot channel
-func (c *WeComBotChannel) Stop(ctx context.Context) error {
-	logger.InfoC("wecom", "Stopping WeCom Bot channel...")
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	if c.server != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		c.server.Shutdown(shutdownCtx)
-	}
-
-	c.setRunning(false)
-	logger.InfoC("wecom", "WeCom Bot channel stopped")
-	return nil
-}
-
-// Send sends a message to WeCom user via webhook API
-// Note: WeCom Bot can only reply within the configured timeout (default 5 seconds) of receiving a message
-// For delayed responses, we use the webhook URL
-func (c *WeComBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("wecom channel not running")
-	}
-
-	logger.DebugCF("wecom", "Sending message via webhook", map[string]any{
-		"chat_id": msg.ChatID,
-		"preview": utils.Truncate(msg.Content, 100),
-	})
-
-	return c.sendWebhookReply(ctx, msg.ChatID, msg.Content)
-}
-
-// handleWebhook handles incoming webhook requests from WeCom
-func (c *WeComBotChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	if r.Method == http.MethodGet {
-		// Handle verification request
-		c.handleVerification(ctx, w, r)
-		return
-	}
-
-	if r.Method == http.MethodPost {
-		// Handle message callback
-		c.handleMessageCallback(ctx, w, r)
-		return
-	}
-
-	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-}
-
-// handleVerification handles the URL verification request from WeCom
-func (c *WeComBotChannel) handleVerification(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	query := r.URL.Query()
-	msgSignature := query.Get("msg_signature")
-	timestamp := query.Get("timestamp")
-	nonce := query.Get("nonce")
-	echostr := query.Get("echostr")
-
-	if msgSignature == "" || timestamp == "" || nonce == "" || echostr == "" {
-		http.Error(w, "Missing parameters", http.StatusBadRequest)
-		return
-	}
-
-	// Verify signature
-	if !WeComVerifySignature(c.config.Token, msgSignature, timestamp, nonce, echostr) {
-		logger.WarnC("wecom", "Signature verification failed")
-		http.Error(w, "Invalid signature", http.StatusForbidden)
-		return
-	}
-
-	// Decrypt echostr
-	// For AIBOT (智能机器人), receiveid should be empty string ""
-	// Reference: https://developer.work.weixin.qq.com/document/path/101033
-	decryptedEchoStr, err := WeComDecryptMessageWithVerify(echostr, c.config.EncodingAESKey, "")
-	if err != nil {
-		logger.ErrorCF("wecom", "Failed to decrypt echostr", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Decryption failed", http.StatusInternalServerError)
-		return
-	}
-
-	// Remove BOM and whitespace as per WeCom documentation
-	// The response must be plain text without quotes, BOM, or newlines
-	decryptedEchoStr = strings.TrimSpace(decryptedEchoStr)
-	decryptedEchoStr = strings.TrimPrefix(decryptedEchoStr, "\xef\xbb\xbf") // Remove UTF-8 BOM
-	w.Write([]byte(decryptedEchoStr))
-}
-
-// handleMessageCallback handles incoming messages from WeCom
-func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	query := r.URL.Query()
-	msgSignature := query.Get("msg_signature")
-	timestamp := query.Get("timestamp")
-	nonce := query.Get("nonce")
-
-	if msgSignature == "" || timestamp == "" || nonce == "" {
-		http.Error(w, "Missing parameters", http.StatusBadRequest)
-		return
-	}
-
-	// Read request body
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, "Failed to read body", http.StatusBadRequest)
-		return
-	}
-	defer r.Body.Close()
-
-	// Parse XML to get encrypted message
-	var encryptedMsg struct {
-		XMLName    xml.Name `xml:"xml"`
-		ToUserName string   `xml:"ToUserName"`
-		Encrypt    string   `xml:"Encrypt"`
-		AgentID    string   `xml:"AgentID"`
-	}
-
-	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
-		logger.ErrorCF("wecom", "Failed to parse XML", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Invalid XML", http.StatusBadRequest)
-		return
-	}
-
-	// Verify signature
-	if !WeComVerifySignature(c.config.Token, msgSignature, timestamp, nonce, encryptedMsg.Encrypt) {
-		logger.WarnC("wecom", "Message signature verification failed")
-		http.Error(w, "Invalid signature", http.StatusForbidden)
-		return
-	}
-
-	// Decrypt message
-	// For AIBOT (智能机器人), receiveid should be empty string ""
-	// Reference: https://developer.work.weixin.qq.com/document/path/101033
-	decryptedMsg, err := WeComDecryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, "")
-	if err != nil {
-		logger.ErrorCF("wecom", "Failed to decrypt message", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Decryption failed", http.StatusInternalServerError)
-		return
-	}
-
-	// Parse decrypted JSON message (AIBOT uses JSON format)
-	var msg WeComBotMessage
-	if err := json.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
-		logger.ErrorCF("wecom", "Failed to parse decrypted message", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Invalid message format", http.StatusBadRequest)
-		return
-	}
-
-	// Process the message asynchronously with context
-	go c.processMessage(ctx, msg)
-
-	// Return success response immediately
-	// WeCom Bot requires response within configured timeout (default 5 seconds)
-	w.Write([]byte("success"))
-}
-
-// processMessage processes the received message
-func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessage) {
-	// Skip unsupported message types
-	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" && msg.MsgType != "file" &&
-		msg.MsgType != "mixed" {
-		logger.DebugCF("wecom", "Skipping non-supported message type", map[string]any{
-			"msg_type": msg.MsgType,
-		})
-		return
-	}
-
-	// Message deduplication: Use msg_id to prevent duplicate processing
-	msgID := msg.MsgID
-	c.msgMu.Lock()
-	if c.processedMsgs[msgID] {
-		c.msgMu.Unlock()
-		logger.DebugCF("wecom", "Skipping duplicate message", map[string]any{
-			"msg_id": msgID,
-		})
-		return
-	}
-	c.processedMsgs[msgID] = true
-	c.msgMu.Unlock()
-
-	// Clean up old messages periodically (keep last 1000)
-	if len(c.processedMsgs) > 1000 {
-		c.msgMu.Lock()
-		c.processedMsgs = make(map[string]bool)
-		c.msgMu.Unlock()
-	}
-
-	senderID := msg.From.UserID
-
-	// Determine if this is a group chat or direct message
-	// ChatType: "single" for DM, "group" for group chat
-	isGroupChat := msg.ChatType == "group"
-
-	var chatID, peerKind, peerID string
-	if isGroupChat {
-		// Group chat: use ChatID as chatID and peer_id
-		chatID = msg.ChatID
-		peerKind = "group"
-		peerID = msg.ChatID
-	} else {
-		// Direct message: use senderID as chatID and peer_id
-		chatID = senderID
-		peerKind = "direct"
-		peerID = senderID
-	}
-
-	// Extract content based on message type
-	var content string
-	switch msg.MsgType {
-	case "text":
-		content = msg.Text.Content
-	case "voice":
-		content = msg.Voice.Content // Voice to text content
-	case "mixed":
-		// For mixed messages, concatenate text items
-		for _, item := range msg.Mixed.MsgItem {
-			if item.MsgType == "text" {
-				content += item.Text.Content
-			}
-		}
-	case "image", "file":
-		// For image and file, we don't have text content
-		content = ""
-	}
-
-	// Build metadata
-	metadata := map[string]string{
-		"msg_type":     msg.MsgType,
-		"msg_id":       msg.MsgID,
-		"platform":     "wecom",
-		"peer_kind":    peerKind,
-		"peer_id":      peerID,
-		"response_url": msg.ResponseURL,
-	}
-	if isGroupChat {
-		metadata["chat_id"] = msg.ChatID
-		metadata["sender_id"] = senderID
-	}
-
-	logger.DebugCF("wecom", "Received message", map[string]any{
-		"sender_id":     senderID,
-		"msg_type":      msg.MsgType,
-		"peer_kind":     peerKind,
-		"is_group_chat": isGroupChat,
-		"preview":       utils.Truncate(content, 50),
-	})
-
-	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-}
-
-// sendWebhookReply sends a reply using the webhook URL
-func (c *WeComBotChannel) sendWebhookReply(ctx context.Context, userID, content string) error {
-	reply := WeComBotReplyMessage{
-		MsgType: "text",
-	}
-	reply.Text.Content = content
-
-	jsonData, err := json.Marshal(reply)
-	if err != nil {
-		return fmt.Errorf("failed to marshal reply: %w", err)
-	}
-
-	// Use configurable timeout (default 5 seconds)
-	timeout := c.config.ReplyTimeout
-	if timeout <= 0 {
-		timeout = 5
-	}
-
-	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, c.config.WebhookURL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send webhook reply: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	// Check response
-	var result struct {
-		ErrCode int    `json:"errcode"`
-		ErrMsg  string `json:"errmsg"`
-	}
-	if err := json.Unmarshal(body, &result); err != nil {
-		return fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	if result.ErrCode != 0 {
-		return fmt.Errorf("webhook API error: %s (code: %d)", result.ErrMsg, result.ErrCode)
-	}
-
-	return nil
-}
-
-// handleHealth handles health check requests
-func (c *WeComBotChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
-	status := map[string]any{
-		"status":  "ok",
-		"running": c.IsRunning(),
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(status)
-}
-
-// WeCom common utilities for both WeCom Bot and WeCom App
-// The following functions were moved from wecom_common.go
-
-// WeComVerifySignature verifies the message signature for WeCom
-// This is a common function used by both WeCom Bot and WeCom App
-func WeComVerifySignature(token, msgSignature, timestamp, nonce, msgEncrypt string) bool {
-	if token == "" {
-		return true // Skip verification if token is not set
-	}
-
-	// Sort parameters
-	params := []string{token, timestamp, nonce, msgEncrypt}
-	sort.Strings(params)
-
-	// Concatenate
-	str := strings.Join(params, "")
-
-	// SHA1 hash
-	hash := sha1.Sum([]byte(str))
-	expectedSignature := fmt.Sprintf("%x", hash)
-
-	return expectedSignature == msgSignature
-}
-
-// WeComDecryptMessage decrypts the encrypted message using AES
-// This is a common function used by both WeCom Bot and WeCom App
-// For AIBOT, receiveid should be the aibotid; for other apps, it should be corp_id
-func WeComDecryptMessage(encryptedMsg, encodingAESKey string) (string, error) {
-	return WeComDecryptMessageWithVerify(encryptedMsg, encodingAESKey, "")
-}
-
-// WeComDecryptMessageWithVerify decrypts the encrypted message and optionally verifies receiveid
-// receiveid: for AIBOT use aibotid, for WeCom App use corp_id. If empty, skip verification.
-func WeComDecryptMessageWithVerify(encryptedMsg, encodingAESKey, receiveid string) (string, error) {
-	if encodingAESKey == "" {
-		// No encryption, return as is (base64 decode)
-		decoded, err := base64.StdEncoding.DecodeString(encryptedMsg)
-		if err != nil {
-			return "", err
-		}
-		return string(decoded), nil
-	}
-
-	// Decode AES key (base64)
-	aesKey, err := base64.StdEncoding.DecodeString(encodingAESKey + "=")
-	if err != nil {
-		return "", fmt.Errorf("failed to decode AES key: %w", err)
-	}
-
-	// Decode encrypted message
-	cipherText, err := base64.StdEncoding.DecodeString(encryptedMsg)
-	if err != nil {
-		return "", fmt.Errorf("failed to decode message: %w", err)
-	}
-
-	// AES decrypt
-	block, err := aes.NewCipher(aesKey)
-	if err != nil {
-		return "", fmt.Errorf("failed to create cipher: %w", err)
-	}
-
-	if len(cipherText) < aes.BlockSize {
-		return "", fmt.Errorf("ciphertext too short")
-	}
-
-	// IV is the first 16 bytes of AESKey
-	iv := aesKey[:aes.BlockSize]
-	mode := cipher.NewCBCDecrypter(block, iv)
-	plainText := make([]byte, len(cipherText))
-	mode.CryptBlocks(plainText, cipherText)
-
-	// Remove PKCS7 padding
-	plainText, err = pkcs7UnpadWeCom(plainText)
-	if err != nil {
-		return "", fmt.Errorf("failed to unpad: %w", err)
-	}
-
-	// Parse message structure
-	// Format: random(16) + msg_len(4) + msg + receiveid
-	if len(plainText) < 20 {
-		return "", fmt.Errorf("decrypted message too short")
-	}
-
-	msgLen := binary.BigEndian.Uint32(plainText[16:20])
-	if int(msgLen) > len(plainText)-20 {
-		return "", fmt.Errorf("invalid message length")
-	}
-
-	msg := plainText[20 : 20+msgLen]
-
-	// Verify receiveid if provided
-	if receiveid != "" && len(plainText) > 20+int(msgLen) {
-		actualReceiveID := string(plainText[20+msgLen:])
-		if actualReceiveID != receiveid {
-			return "", fmt.Errorf("receiveid mismatch: expected %s, got %s", receiveid, actualReceiveID)
-		}
-	}
-
-	return string(msg), nil
-}
-
-// pkcs7UnpadWeCom removes PKCS7 padding with validation
-// WeCom uses block size of 32 (not standard AES block size of 16)
-const wecomBlockSize = 32
-
-func pkcs7UnpadWeCom(data []byte) ([]byte, error) {
-	if len(data) == 0 {
-		return data, nil
-	}
-	padding := int(data[len(data)-1])
-	// WeCom uses 32-byte block size for PKCS7 padding
-	if padding == 0 || padding > wecomBlockSize {
-		return nil, fmt.Errorf("invalid padding size: %d", padding)
-	}
-	if padding > len(data) {
-		return nil, fmt.Errorf("padding size larger than data")
-	}
-	// Verify all padding bytes
-	for i := 0; i < padding; i++ {
-		if data[len(data)-1-i] != byte(padding) {
-			return nil, fmt.Errorf("invalid padding byte at position %d", i)
-		}
-	}
-	return data[:len(data)-padding], nil
-}
diff --git a/pkg/channels/wecom_app.go b/pkg/channels/wecom_app.go
deleted file mode 100644
index 715c48707..000000000
--- a/pkg/channels/wecom_app.go
+++ /dev/null
@@ -1,639 +0,0 @@
-// PicoClaw - Ultra-lightweight personal AI agent
-// WeCom App (企业微信自建应用) channel implementation
-// Supports receiving messages via webhook callback and sending messages proactively
-
-package channels
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-const (
-	wecomAPIBase = "https://qyapi.weixin.qq.com"
-)
-
-// WeComAppChannel implements the Channel interface for WeCom App (企业微信自建应用)
-type WeComAppChannel struct {
-	*BaseChannel
-	config        config.WeComAppConfig
-	server        *http.Server
-	accessToken   string
-	tokenExpiry   time.Time
-	tokenMu       sync.RWMutex
-	ctx           context.Context
-	cancel        context.CancelFunc
-	processedMsgs map[string]bool // Message deduplication: msg_id -> processed
-	msgMu         sync.RWMutex
-}
-
-// WeComXMLMessage represents the XML message structure from WeCom
-type WeComXMLMessage struct {
-	XMLName      xml.Name `xml:"xml"`
-	ToUserName   string   `xml:"ToUserName"`
-	FromUserName string   `xml:"FromUserName"`
-	CreateTime   int64    `xml:"CreateTime"`
-	MsgType      string   `xml:"MsgType"`
-	Content      string   `xml:"Content"`
-	MsgId        int64    `xml:"MsgId"`
-	AgentID      int64    `xml:"AgentID"`
-	PicUrl       string   `xml:"PicUrl"`
-	MediaId      string   `xml:"MediaId"`
-	Format       string   `xml:"Format"`
-	ThumbMediaId string   `xml:"ThumbMediaId"`
-	LocationX    float64  `xml:"Location_X"`
-	LocationY    float64  `xml:"Location_Y"`
-	Scale        int      `xml:"Scale"`
-	Label        string   `xml:"Label"`
-	Title        string   `xml:"Title"`
-	Description  string   `xml:"Description"`
-	Url          string   `xml:"Url"`
-	Event        string   `xml:"Event"`
-	EventKey     string   `xml:"EventKey"`
-}
-
-// WeComTextMessage represents text message for sending
-type WeComTextMessage struct {
-	ToUser  string `json:"touser"`
-	MsgType string `json:"msgtype"`
-	AgentID int64  `json:"agentid"`
-	Text    struct {
-		Content string `json:"content"`
-	} `json:"text"`
-	Safe int `json:"safe,omitempty"`
-}
-
-// WeComMarkdownMessage represents markdown message for sending
-type WeComMarkdownMessage struct {
-	ToUser   string `json:"touser"`
-	MsgType  string `json:"msgtype"`
-	AgentID  int64  `json:"agentid"`
-	Markdown struct {
-		Content string `json:"content"`
-	} `json:"markdown"`
-}
-
-// WeComImageMessage represents image message for sending
-type WeComImageMessage struct {
-	ToUser  string `json:"touser"`
-	MsgType string `json:"msgtype"`
-	AgentID int64  `json:"agentid"`
-	Image   struct {
-		MediaID string `json:"media_id"`
-	} `json:"image"`
-}
-
-// WeComAccessTokenResponse represents the access token API response
-type WeComAccessTokenResponse struct {
-	ErrCode     int    `json:"errcode"`
-	ErrMsg      string `json:"errmsg"`
-	AccessToken string `json:"access_token"`
-	ExpiresIn   int    `json:"expires_in"`
-}
-
-// WeComSendMessageResponse represents the send message API response
-type WeComSendMessageResponse struct {
-	ErrCode      int    `json:"errcode"`
-	ErrMsg       string `json:"errmsg"`
-	InvalidUser  string `json:"invaliduser"`
-	InvalidParty string `json:"invalidparty"`
-	InvalidTag   string `json:"invalidtag"`
-}
-
-// PKCS7Padding adds PKCS7 padding
-type PKCS7Padding struct{}
-
-// NewWeComAppChannel creates a new WeCom App channel instance
-func NewWeComAppChannel(cfg config.WeComAppConfig, messageBus *bus.MessageBus) (*WeComAppChannel, error) {
-	if cfg.CorpID == "" || cfg.CorpSecret == "" || cfg.AgentID == 0 {
-		return nil, fmt.Errorf("wecom_app corp_id, corp_secret and agent_id are required")
-	}
-
-	base := NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom)
-
-	return &WeComAppChannel{
-		BaseChannel:   base,
-		config:        cfg,
-		processedMsgs: make(map[string]bool),
-	}, nil
-}
-
-// Name returns the channel name
-func (c *WeComAppChannel) Name() string {
-	return "wecom_app"
-}
-
-// Start initializes the WeCom App channel with HTTP webhook server
-func (c *WeComAppChannel) Start(ctx context.Context) error {
-	logger.InfoC("wecom_app", "Starting WeCom App channel...")
-
-	c.ctx, c.cancel = context.WithCancel(ctx)
-
-	// Get initial access token
-	if err := c.refreshAccessToken(); err != nil {
-		logger.WarnCF("wecom_app", "Failed to get initial access token", map[string]any{
-			"error": err.Error(),
-		})
-	}
-
-	// Start token refresh goroutine
-	go c.tokenRefreshLoop()
-
-	// Setup HTTP server for webhook
-	mux := http.NewServeMux()
-	webhookPath := c.config.WebhookPath
-	if webhookPath == "" {
-		webhookPath = "/webhook/wecom-app"
-	}
-	mux.HandleFunc(webhookPath, c.handleWebhook)
-
-	// Health check endpoint
-	mux.HandleFunc("/health/wecom-app", c.handleHealth)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.server = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
-	c.setRunning(true)
-	logger.InfoCF("wecom_app", "WeCom App channel started", map[string]any{
-		"address": addr,
-		"path":    webhookPath,
-	})
-
-	// Start server in goroutine
-	go func() {
-		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom_app", "HTTP server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
-
-	return nil
-}
-
-// Stop gracefully stops the WeCom App channel
-func (c *WeComAppChannel) Stop(ctx context.Context) error {
-	logger.InfoC("wecom_app", "Stopping WeCom App channel...")
-
-	if c.cancel != nil {
-		c.cancel()
-	}
-
-	if c.server != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		c.server.Shutdown(shutdownCtx)
-	}
-
-	c.setRunning(false)
-	logger.InfoC("wecom_app", "WeCom App channel stopped")
-	return nil
-}
-
-// Send sends a message to WeCom user proactively using access token
-func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	if !c.IsRunning() {
-		return fmt.Errorf("wecom_app channel not running")
-	}
-
-	accessToken := c.getAccessToken()
-	if accessToken == "" {
-		return fmt.Errorf("no valid access token available")
-	}
-
-	logger.DebugCF("wecom_app", "Sending message", map[string]any{
-		"chat_id": msg.ChatID,
-		"preview": utils.Truncate(msg.Content, 100),
-	})
-
-	return c.sendTextMessage(ctx, accessToken, msg.ChatID, msg.Content)
-}
-
-// handleWebhook handles incoming webhook requests from WeCom
-func (c *WeComAppChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	// Log all incoming requests for debugging
-	logger.DebugCF("wecom_app", "Received webhook request", map[string]any{
-		"method": r.Method,
-		"url":    r.URL.String(),
-		"path":   r.URL.Path,
-		"query":  r.URL.RawQuery,
-	})
-
-	if r.Method == http.MethodGet {
-		// Handle verification request
-		c.handleVerification(ctx, w, r)
-		return
-	}
-
-	if r.Method == http.MethodPost {
-		// Handle message callback
-		c.handleMessageCallback(ctx, w, r)
-		return
-	}
-
-	logger.WarnCF("wecom_app", "Method not allowed", map[string]any{
-		"method": r.Method,
-	})
-	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-}
-
-// handleVerification handles the URL verification request from WeCom
-func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	query := r.URL.Query()
-	msgSignature := query.Get("msg_signature")
-	timestamp := query.Get("timestamp")
-	nonce := query.Get("nonce")
-	echostr := query.Get("echostr")
-
-	logger.DebugCF("wecom_app", "Handling verification request", map[string]any{
-		"msg_signature": msgSignature,
-		"timestamp":     timestamp,
-		"nonce":         nonce,
-		"echostr":       echostr,
-		"corp_id":       c.config.CorpID,
-	})
-
-	if msgSignature == "" || timestamp == "" || nonce == "" || echostr == "" {
-		logger.ErrorC("wecom_app", "Missing parameters in verification request")
-		http.Error(w, "Missing parameters", http.StatusBadRequest)
-		return
-	}
-
-	// Verify signature
-	if !WeComVerifySignature(c.config.Token, msgSignature, timestamp, nonce, echostr) {
-		logger.WarnCF("wecom_app", "Signature verification failed", map[string]any{
-			"token":         c.config.Token,
-			"msg_signature": msgSignature,
-			"timestamp":     timestamp,
-			"nonce":         nonce,
-		})
-		http.Error(w, "Invalid signature", http.StatusForbidden)
-		return
-	}
-
-	logger.DebugC("wecom_app", "Signature verification passed")
-
-	// Decrypt echostr with CorpID verification
-	// For WeCom App (自建应用), receiveid should be corp_id
-	logger.DebugCF("wecom_app", "Attempting to decrypt echostr", map[string]any{
-		"encoding_aes_key": c.config.EncodingAESKey,
-		"corp_id":          c.config.CorpID,
-	})
-	decryptedEchoStr, err := WeComDecryptMessageWithVerify(echostr, c.config.EncodingAESKey, c.config.CorpID)
-	if err != nil {
-		logger.ErrorCF("wecom_app", "Failed to decrypt echostr", map[string]any{
-			"error":            err.Error(),
-			"encoding_aes_key": c.config.EncodingAESKey,
-			"corp_id":          c.config.CorpID,
-		})
-		http.Error(w, "Decryption failed", http.StatusInternalServerError)
-		return
-	}
-
-	logger.DebugCF("wecom_app", "Successfully decrypted echostr", map[string]any{
-		"decrypted": decryptedEchoStr,
-	})
-
-	// Remove BOM and whitespace as per WeCom documentation
-	// The response must be plain text without quotes, BOM, or newlines
-	decryptedEchoStr = strings.TrimSpace(decryptedEchoStr)
-	decryptedEchoStr = strings.TrimPrefix(decryptedEchoStr, "\xef\xbb\xbf") // Remove UTF-8 BOM
-	w.Write([]byte(decryptedEchoStr))
-}
-
-// handleMessageCallback handles incoming messages from WeCom
-func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	query := r.URL.Query()
-	msgSignature := query.Get("msg_signature")
-	timestamp := query.Get("timestamp")
-	nonce := query.Get("nonce")
-
-	if msgSignature == "" || timestamp == "" || nonce == "" {
-		http.Error(w, "Missing parameters", http.StatusBadRequest)
-		return
-	}
-
-	// Read request body
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, "Failed to read body", http.StatusBadRequest)
-		return
-	}
-	defer r.Body.Close()
-
-	// Parse XML to get encrypted message
-	var encryptedMsg struct {
-		XMLName    xml.Name `xml:"xml"`
-		ToUserName string   `xml:"ToUserName"`
-		Encrypt    string   `xml:"Encrypt"`
-		AgentID    string   `xml:"AgentID"`
-	}
-
-	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
-		logger.ErrorCF("wecom_app", "Failed to parse XML", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Invalid XML", http.StatusBadRequest)
-		return
-	}
-
-	// Verify signature
-	if !WeComVerifySignature(c.config.Token, msgSignature, timestamp, nonce, encryptedMsg.Encrypt) {
-		logger.WarnC("wecom_app", "Message signature verification failed")
-		http.Error(w, "Invalid signature", http.StatusForbidden)
-		return
-	}
-
-	// Decrypt message with CorpID verification
-	// For WeCom App (自建应用), receiveid should be corp_id
-	decryptedMsg, err := WeComDecryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, c.config.CorpID)
-	if err != nil {
-		logger.ErrorCF("wecom_app", "Failed to decrypt message", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Decryption failed", http.StatusInternalServerError)
-		return
-	}
-
-	// Parse decrypted XML message
-	var msg WeComXMLMessage
-	if err := xml.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
-		logger.ErrorCF("wecom_app", "Failed to parse decrypted message", map[string]any{
-			"error": err.Error(),
-		})
-		http.Error(w, "Invalid message format", http.StatusBadRequest)
-		return
-	}
-
-	// Process the message with context
-	go c.processMessage(ctx, msg)
-
-	// Return success response immediately
-	// WeCom App requires response within configured timeout (default 5 seconds)
-	w.Write([]byte("success"))
-}
-
-// processMessage processes the received message
-func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessage) {
-	// Skip non-text messages for now (can be extended)
-	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" {
-		logger.DebugCF("wecom_app", "Skipping non-supported message type", map[string]any{
-			"msg_type": msg.MsgType,
-		})
-		return
-	}
-
-	// Message deduplication: Use msg_id to prevent duplicate processing
-	// As per WeCom documentation, use msg_id for deduplication
-	msgID := fmt.Sprintf("%d", msg.MsgId)
-	c.msgMu.Lock()
-	if c.processedMsgs[msgID] {
-		c.msgMu.Unlock()
-		logger.DebugCF("wecom_app", "Skipping duplicate message", map[string]any{
-			"msg_id": msgID,
-		})
-		return
-	}
-	c.processedMsgs[msgID] = true
-	c.msgMu.Unlock()
-
-	// Clean up old messages periodically (keep last 1000)
-	if len(c.processedMsgs) > 1000 {
-		c.msgMu.Lock()
-		c.processedMsgs = make(map[string]bool)
-		c.msgMu.Unlock()
-	}
-
-	senderID := msg.FromUserName
-	chatID := senderID // WeCom App uses user ID as chat ID for direct messages
-
-	// Build metadata
-	// WeCom App only supports direct messages (private chat)
-	metadata := map[string]string{
-		"msg_type":    msg.MsgType,
-		"msg_id":      fmt.Sprintf("%d", msg.MsgId),
-		"agent_id":    fmt.Sprintf("%d", msg.AgentID),
-		"platform":    "wecom_app",
-		"media_id":    msg.MediaId,
-		"create_time": fmt.Sprintf("%d", msg.CreateTime),
-		"peer_kind":   "direct",
-		"peer_id":     senderID,
-	}
-
-	content := msg.Content
-
-	logger.DebugCF("wecom_app", "Received message", map[string]any{
-		"sender_id": senderID,
-		"msg_type":  msg.MsgType,
-		"preview":   utils.Truncate(content, 50),
-	})
-
-	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
-}
-
-// tokenRefreshLoop periodically refreshes the access token
-func (c *WeComAppChannel) tokenRefreshLoop() {
-	ticker := time.NewTicker(5 * time.Minute)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-c.ctx.Done():
-			return
-		case <-ticker.C:
-			if err := c.refreshAccessToken(); err != nil {
-				logger.ErrorCF("wecom_app", "Failed to refresh access token", map[string]any{
-					"error": err.Error(),
-				})
-			}
-		}
-	}
-}
-
-// refreshAccessToken gets a new access token from WeCom API
-func (c *WeComAppChannel) refreshAccessToken() error {
-	apiURL := fmt.Sprintf("%s/cgi-bin/gettoken?corpid=%s&corpsecret=%s",
-		wecomAPIBase, url.QueryEscape(c.config.CorpID), url.QueryEscape(c.config.CorpSecret))
-
-	resp, err := http.Get(apiURL)
-	if err != nil {
-		return fmt.Errorf("failed to request access token: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	var tokenResp WeComAccessTokenResponse
-	if err := json.Unmarshal(body, &tokenResp); err != nil {
-		return fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	if tokenResp.ErrCode != 0 {
-		return fmt.Errorf("API error: %s (code: %d)", tokenResp.ErrMsg, tokenResp.ErrCode)
-	}
-
-	c.tokenMu.Lock()
-	c.accessToken = tokenResp.AccessToken
-	c.tokenExpiry = time.Now().Add(time.Duration(tokenResp.ExpiresIn-300) * time.Second) // Refresh 5 minutes early
-	c.tokenMu.Unlock()
-
-	logger.DebugC("wecom_app", "Access token refreshed successfully")
-	return nil
-}
-
-// getAccessToken returns the current valid access token
-func (c *WeComAppChannel) getAccessToken() string {
-	c.tokenMu.RLock()
-	defer c.tokenMu.RUnlock()
-
-	if time.Now().After(c.tokenExpiry) {
-		return ""
-	}
-
-	return c.accessToken
-}
-
-// sendTextMessage sends a text message to a user
-func (c *WeComAppChannel) sendTextMessage(ctx context.Context, accessToken, userID, content string) error {
-	apiURL := fmt.Sprintf("%s/cgi-bin/message/send?access_token=%s", wecomAPIBase, accessToken)
-
-	msg := WeComTextMessage{
-		ToUser:  userID,
-		MsgType: "text",
-		AgentID: c.config.AgentID,
-	}
-	msg.Text.Content = content
-
-	jsonData, err := json.Marshal(msg)
-	if err != nil {
-		return fmt.Errorf("failed to marshal message: %w", err)
-	}
-
-	// Use configurable timeout (default 5 seconds)
-	timeout := c.config.ReplyTimeout
-	if timeout <= 0 {
-		timeout = 5
-	}
-
-	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, apiURL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	var sendResp WeComSendMessageResponse
-	if err := json.Unmarshal(body, &sendResp); err != nil {
-		return fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	if sendResp.ErrCode != 0 {
-		return fmt.Errorf("API error: %s (code: %d)", sendResp.ErrMsg, sendResp.ErrCode)
-	}
-
-	return nil
-}
-
-// sendMarkdownMessage sends a markdown message to a user
-func (c *WeComAppChannel) sendMarkdownMessage(ctx context.Context, accessToken, userID, content string) error {
-	apiURL := fmt.Sprintf("%s/cgi-bin/message/send?access_token=%s", wecomAPIBase, accessToken)
-
-	msg := WeComMarkdownMessage{
-		ToUser:  userID,
-		MsgType: "markdown",
-		AgentID: c.config.AgentID,
-	}
-	msg.Markdown.Content = content
-
-	jsonData, err := json.Marshal(msg)
-	if err != nil {
-		return fmt.Errorf("failed to marshal message: %w", err)
-	}
-
-	// Use configurable timeout (default 5 seconds)
-	timeout := c.config.ReplyTimeout
-	if timeout <= 0 {
-		timeout = 5
-	}
-
-	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, apiURL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	var sendResp WeComSendMessageResponse
-	if err := json.Unmarshal(body, &sendResp); err != nil {
-		return fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	if sendResp.ErrCode != 0 {
-		return fmt.Errorf("API error: %s (code: %d)", sendResp.ErrMsg, sendResp.ErrCode)
-	}
-
-	return nil
-}
-
-// handleHealth handles health check requests
-func (c *WeComAppChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
-	status := map[string]any{
-		"status":    "ok",
-		"running":   c.IsRunning(),
-		"has_token": c.getAccessToken() != "",
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(status)
-}
diff --git a/pkg/channels/wecom_app_test.go b/pkg/channels/wecom_app_test.go
deleted file mode 100644
index abf15c52b..000000000
--- a/pkg/channels/wecom_app_test.go
+++ /dev/null
@@ -1,1104 +0,0 @@
-// PicoClaw - Ultra-lightweight personal AI agent
-// WeCom App (企业微信自建应用) channel tests
-
-package channels
-
-import (
-	"bytes"
-	"context"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/sha1"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-// generateTestAESKeyApp generates a valid test AES key for WeCom App
-func generateTestAESKeyApp() string {
-	// AES key needs to be 32 bytes (256 bits) for AES-256
-	key := make([]byte, 32)
-	for i := range key {
-		key[i] = byte(i + 1)
-	}
-	// Return base64 encoded key without padding
-	return base64.StdEncoding.EncodeToString(key)[:43]
-}
-
-// encryptTestMessageApp encrypts a message for testing WeCom App
-func encryptTestMessageApp(message, aesKey string) (string, error) {
-	// Decode AES key
-	key, err := base64.StdEncoding.DecodeString(aesKey + "=")
-	if err != nil {
-		return "", err
-	}
-
-	// Prepare message: random(16) + msg_len(4) + msg + corp_id
-	random := make([]byte, 0, 16)
-	for i := 0; i < 16; i++ {
-		random = append(random, byte(i+1))
-	}
-
-	msgBytes := []byte(message)
-	corpID := []byte("test_corp_id")
-
-	msgLen := uint32(len(msgBytes))
-	lenBytes := make([]byte, 4)
-	binary.BigEndian.PutUint32(lenBytes, msgLen)
-
-	plainText := append(random, lenBytes...)
-	plainText = append(plainText, msgBytes...)
-	plainText = append(plainText, corpID...)
-
-	// PKCS7 padding
-	blockSize := aes.BlockSize
-	padding := blockSize - len(plainText)%blockSize
-	padText := bytes.Repeat([]byte{byte(padding)}, padding)
-	plainText = append(plainText, padText...)
-
-	// Encrypt
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return "", err
-	}
-
-	mode := cipher.NewCBCEncrypter(block, key[:aes.BlockSize])
-	cipherText := make([]byte, len(plainText))
-	mode.CryptBlocks(cipherText, plainText)
-
-	return base64.StdEncoding.EncodeToString(cipherText), nil
-}
-
-// generateSignatureApp generates a signature for testing WeCom App
-func generateSignatureApp(token, timestamp, nonce, msgEncrypt string) string {
-	params := []string{token, timestamp, nonce, msgEncrypt}
-	sort.Strings(params)
-	str := strings.Join(params, "")
-	hash := sha1.Sum([]byte(str))
-	return fmt.Sprintf("%x", hash)
-}
-
-func TestNewWeComAppChannel(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("missing corp_id", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "",
-			CorpSecret: "test_secret",
-			AgentID:    1000002,
-		}
-		_, err := NewWeComAppChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing corp_id, got nil")
-		}
-	})
-
-	t.Run("missing corp_secret", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "",
-			AgentID:    1000002,
-		}
-		_, err := NewWeComAppChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing corp_secret, got nil")
-		}
-	})
-
-	t.Run("missing agent_id", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "test_secret",
-			AgentID:    0,
-		}
-		_, err := NewWeComAppChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing agent_id, got nil")
-		}
-	})
-
-	t.Run("valid config", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "test_secret",
-			AgentID:    1000002,
-			AllowFrom:  []string{"user1", "user2"},
-		}
-		ch, err := NewWeComAppChannel(cfg, msgBus)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if ch.Name() != "wecom_app" {
-			t.Errorf("Name() = %q, want %q", ch.Name(), "wecom_app")
-		}
-		if ch.IsRunning() {
-			t.Error("new channel should not be running")
-		}
-	})
-}
-
-func TestWeComAppChannelIsAllowed(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("empty allowlist allows all", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "test_secret",
-			AgentID:    1000002,
-			AllowFrom:  []string{},
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-		if !ch.IsAllowed("any_user") {
-			t.Error("empty allowlist should allow all users")
-		}
-	})
-
-	t.Run("allowlist restricts users", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "test_secret",
-			AgentID:    1000002,
-			AllowFrom:  []string{"allowed_user"},
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-		if !ch.IsAllowed("allowed_user") {
-			t.Error("allowed user should pass allowlist check")
-		}
-		if ch.IsAllowed("blocked_user") {
-			t.Error("non-allowed user should be blocked")
-		}
-	})
-}
-
-func TestWeComAppVerifySignature(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComAppConfig{
-		CorpID:     "test_corp_id",
-		CorpSecret: "test_secret",
-		AgentID:    1000002,
-		Token:      "test_token",
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("valid signature", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		msgEncrypt := "test_message"
-		expectedSig := generateSignatureApp("test_token", timestamp, nonce, msgEncrypt)
-
-		if !WeComVerifySignature(ch.config.Token, expectedSig, timestamp, nonce, msgEncrypt) {
-			t.Error("valid signature should pass verification")
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		msgEncrypt := "test_message"
-
-		if WeComVerifySignature(ch.config.Token, "invalid_sig", timestamp, nonce, msgEncrypt) {
-			t.Error("invalid signature should fail verification")
-		}
-	})
-
-	t.Run("empty token skips verification", func(t *testing.T) {
-		cfgEmpty := config.WeComAppConfig{
-			CorpID:     "test_corp_id",
-			CorpSecret: "test_secret",
-			AgentID:    1000002,
-			Token:      "",
-		}
-		chEmpty, _ := NewWeComAppChannel(cfgEmpty, msgBus)
-
-		if !WeComVerifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
-			t.Error("empty token should skip verification and return true")
-		}
-	})
-}
-
-func TestWeComAppDecryptMessage(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("decrypt without AES key", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:         "test_corp_id",
-			CorpSecret:     "test_secret",
-			AgentID:        1000002,
-			EncodingAESKey: "",
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-		// Without AES key, message should be base64 decoded only
-		plainText := "hello world"
-		encoded := base64.StdEncoding.EncodeToString([]byte(plainText))
-
-		result, err := WeComDecryptMessage(encoded, ch.config.EncodingAESKey)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if result != plainText {
-			t.Errorf("decryptMessage() = %q, want %q", result, plainText)
-		}
-	})
-
-	t.Run("decrypt with AES key", func(t *testing.T) {
-		aesKey := generateTestAESKeyApp()
-		cfg := config.WeComAppConfig{
-			CorpID:         "test_corp_id",
-			CorpSecret:     "test_secret",
-			AgentID:        1000002,
-			EncodingAESKey: aesKey,
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-		originalMsg := "<xml><Content>Hello</Content></xml>"
-		encrypted, err := encryptTestMessageApp(originalMsg, aesKey)
-		if err != nil {
-			t.Fatalf("failed to encrypt test message: %v", err)
-		}
-
-		result, err := WeComDecryptMessage(encrypted, ch.config.EncodingAESKey)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if result != originalMsg {
-			t.Errorf("WeComDecryptMessage() = %q, want %q", result, originalMsg)
-		}
-	})
-
-	t.Run("invalid base64", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:         "test_corp_id",
-			CorpSecret:     "test_secret",
-			AgentID:        1000002,
-			EncodingAESKey: "",
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-		_, err := WeComDecryptMessage("invalid_base64!!!", ch.config.EncodingAESKey)
-		if err == nil {
-			t.Error("expected error for invalid base64, got nil")
-		}
-	})
-
-	t.Run("invalid AES key", func(t *testing.T) {
-		cfg := config.WeComAppConfig{
-			CorpID:         "test_corp_id",
-			CorpSecret:     "test_secret",
-			AgentID:        1000002,
-			EncodingAESKey: "invalid_key",
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-		_, err := WeComDecryptMessage(base64.StdEncoding.EncodeToString([]byte("test")), ch.config.EncodingAESKey)
-		if err == nil {
-			t.Error("expected error for invalid AES key, got nil")
-		}
-	})
-
-	t.Run("ciphertext too short", func(t *testing.T) {
-		aesKey := generateTestAESKeyApp()
-		cfg := config.WeComAppConfig{
-			CorpID:         "test_corp_id",
-			CorpSecret:     "test_secret",
-			AgentID:        1000002,
-			EncodingAESKey: aesKey,
-		}
-		ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-		// Encrypt a very short message that results in ciphertext less than block size
-		shortData := make([]byte, 8)
-		_, err := WeComDecryptMessage(base64.StdEncoding.EncodeToString(shortData), ch.config.EncodingAESKey)
-		if err == nil {
-			t.Error("expected error for short ciphertext, got nil")
-		}
-	})
-}
-
-func TestWeComAppPKCS7Unpad(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    []byte
-		expected []byte
-	}{
-		{
-			name:     "empty input",
-			input:    []byte{},
-			expected: []byte{},
-		},
-		{
-			name:     "valid padding 3 bytes",
-			input:    append([]byte("hello"), bytes.Repeat([]byte{3}, 3)...),
-			expected: []byte("hello"),
-		},
-		{
-			name:     "valid padding 16 bytes (full block)",
-			input:    append([]byte("123456789012345"), bytes.Repeat([]byte{16}, 16)...),
-			expected: []byte("123456789012345"),
-		},
-		{
-			name:     "invalid padding larger than data",
-			input:    []byte{20},
-			expected: nil, // should return error
-		},
-		{
-			name:     "invalid padding zero",
-			input:    append([]byte("test"), byte(0)),
-			expected: nil, // should return error
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := pkcs7UnpadWeCom(tt.input)
-			if tt.expected == nil {
-				// This case should return an error
-				if err == nil {
-					t.Errorf("pkcs7Unpad() expected error for invalid padding, got result: %v", result)
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("pkcs7Unpad() unexpected error: %v", err)
-				return
-			}
-			if !bytes.Equal(result, tt.expected) {
-				t.Errorf("pkcs7Unpad() = %v, want %v", result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestWeComAppHandleVerification(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	aesKey := generateTestAESKeyApp()
-	cfg := config.WeComAppConfig{
-		CorpID:         "test_corp_id",
-		CorpSecret:     "test_secret",
-		AgentID:        1000002,
-		Token:          "test_token",
-		EncodingAESKey: aesKey,
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("valid verification request", func(t *testing.T) {
-		echostr := "test_echostr_123"
-		encryptedEchostr, _ := encryptTestMessageApp(echostr, aesKey)
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedEchostr)
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-		if w.Body.String() != echostr {
-			t.Errorf("response body = %q, want %q", w.Body.String(), echostr)
-		}
-	})
-
-	t.Run("missing parameters", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature=sig&timestamp=ts", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		echostr := "test_echostr"
-		encryptedEchostr, _ := encryptTestMessageApp(echostr, aesKey)
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusForbidden {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
-		}
-	})
-}
-
-func TestWeComAppHandleMessageCallback(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	aesKey := generateTestAESKeyApp()
-	cfg := config.WeComAppConfig{
-		CorpID:         "test_corp_id",
-		CorpSecret:     "test_secret",
-		AgentID:        1000002,
-		Token:          "test_token",
-		EncodingAESKey: aesKey,
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("valid message callback", func(t *testing.T) {
-		// Create XML message
-		xmlMsg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "text",
-			Content:      "Hello World",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-		xmlData, _ := xml.Marshal(xmlMsg)
-
-		// Encrypt message
-		encrypted, _ := encryptTestMessageApp(string(xmlData), aesKey)
-
-		// Create encrypted XML wrapper
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: encrypted,
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignatureApp("test_token", timestamp, nonce, encrypted)
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-		if w.Body.String() != "success" {
-			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
-		}
-	})
-
-	t.Run("missing parameters", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature=sig", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid XML", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignatureApp("test_token", timestamp, nonce, "")
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			strings.NewReader("invalid xml"),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: "encrypted_data",
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusForbidden {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
-		}
-	})
-}
-
-func TestWeComAppProcessMessage(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComAppConfig{
-		CorpID:     "test_corp_id",
-		CorpSecret: "test_secret",
-		AgentID:    1000002,
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("process text message", func(t *testing.T) {
-		msg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "text",
-			Content:      "Hello World",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("process image message", func(t *testing.T) {
-		msg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "image",
-			PicUrl:       "https://example.com/image.jpg",
-			MediaId:      "media_123",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("process voice message", func(t *testing.T) {
-		msg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "voice",
-			MediaId:      "media_123",
-			Format:       "amr",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("skip unsupported message type", func(t *testing.T) {
-		msg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "video",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("process event message", func(t *testing.T) {
-		msg := WeComXMLMessage{
-			ToUserName:   "corp_id",
-			FromUserName: "user123",
-			CreateTime:   1234567890,
-			MsgType:      "event",
-			Event:        "subscribe",
-			MsgId:        123456,
-			AgentID:      1000002,
-		}
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-}
-
-func TestWeComAppHandleWebhook(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComAppConfig{
-		CorpID:     "test_corp_id",
-		CorpSecret: "test_secret",
-		AgentID:    1000002,
-		Token:      "test_token",
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("GET request calls verification", func(t *testing.T) {
-		echostr := "test_echostr"
-		encoded := base64.StdEncoding.EncodeToString([]byte(echostr))
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignatureApp("test_token", timestamp, nonce, encoded)
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-	})
-
-	t.Run("POST request calls message callback", func(t *testing.T) {
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: base64.StdEncoding.EncodeToString([]byte("test")),
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		// Should not be method not allowed
-		if w.Code == http.StatusMethodNotAllowed {
-			t.Error("POST request should not return Method Not Allowed")
-		}
-	})
-
-	t.Run("unsupported method", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodPut, "/webhook/wecom-app", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		if w.Code != http.StatusMethodNotAllowed {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusMethodNotAllowed)
-		}
-	})
-}
-
-func TestWeComAppHandleHealth(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComAppConfig{
-		CorpID:     "test_corp_id",
-		CorpSecret: "test_secret",
-		AgentID:    1000002,
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	req := httptest.NewRequest(http.MethodGet, "/health/wecom-app", nil)
-	w := httptest.NewRecorder()
-
-	ch.handleHealth(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-	}
-
-	contentType := w.Header().Get("Content-Type")
-	if contentType != "application/json" {
-		t.Errorf("Content-Type = %q, want %q", contentType, "application/json")
-	}
-
-	body := w.Body.String()
-	if !strings.Contains(body, "status") || !strings.Contains(body, "running") || !strings.Contains(body, "has_token") {
-		t.Errorf("response body should contain status, running, and has_token fields, got: %s", body)
-	}
-}
-
-func TestWeComAppAccessToken(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComAppConfig{
-		CorpID:     "test_corp_id",
-		CorpSecret: "test_secret",
-		AgentID:    1000002,
-	}
-	ch, _ := NewWeComAppChannel(cfg, msgBus)
-
-	t.Run("get empty access token initially", func(t *testing.T) {
-		token := ch.getAccessToken()
-		if token != "" {
-			t.Errorf("getAccessToken() = %q, want empty string", token)
-		}
-	})
-
-	t.Run("set and get access token", func(t *testing.T) {
-		ch.tokenMu.Lock()
-		ch.accessToken = "test_token_123"
-		ch.tokenExpiry = time.Now().Add(1 * time.Hour)
-		ch.tokenMu.Unlock()
-
-		token := ch.getAccessToken()
-		if token != "test_token_123" {
-			t.Errorf("getAccessToken() = %q, want %q", token, "test_token_123")
-		}
-	})
-
-	t.Run("expired token returns empty", func(t *testing.T) {
-		ch.tokenMu.Lock()
-		ch.accessToken = "expired_token"
-		ch.tokenExpiry = time.Now().Add(-1 * time.Hour)
-		ch.tokenMu.Unlock()
-
-		token := ch.getAccessToken()
-		if token != "" {
-			t.Errorf("getAccessToken() = %q, want empty string for expired token", token)
-		}
-	})
-}
-
-func TestWeComAppMessageStructures(t *testing.T) {
-	t.Run("WeComTextMessage structure", func(t *testing.T) {
-		msg := WeComTextMessage{
-			ToUser:  "user123",
-			MsgType: "text",
-			AgentID: 1000002,
-		}
-		msg.Text.Content = "Hello World"
-
-		if msg.ToUser != "user123" {
-			t.Errorf("ToUser = %q, want %q", msg.ToUser, "user123")
-		}
-		if msg.MsgType != "text" {
-			t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
-		}
-		if msg.AgentID != 1000002 {
-			t.Errorf("AgentID = %d, want %d", msg.AgentID, 1000002)
-		}
-		if msg.Text.Content != "Hello World" {
-			t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
-		}
-
-		// Test JSON marshaling
-		jsonData, err := json.Marshal(msg)
-		if err != nil {
-			t.Fatalf("failed to marshal JSON: %v", err)
-		}
-
-		var unmarshaled WeComTextMessage
-		err = json.Unmarshal(jsonData, &unmarshaled)
-		if err != nil {
-			t.Fatalf("failed to unmarshal JSON: %v", err)
-		}
-
-		if unmarshaled.ToUser != msg.ToUser {
-			t.Errorf("JSON round-trip failed for ToUser")
-		}
-	})
-
-	t.Run("WeComMarkdownMessage structure", func(t *testing.T) {
-		msg := WeComMarkdownMessage{
-			ToUser:  "user123",
-			MsgType: "markdown",
-			AgentID: 1000002,
-		}
-		msg.Markdown.Content = "# Hello\nWorld"
-
-		if msg.Markdown.Content != "# Hello\nWorld" {
-			t.Errorf("Markdown.Content = %q, want %q", msg.Markdown.Content, "# Hello\nWorld")
-		}
-
-		// Test JSON marshaling
-		jsonData, err := json.Marshal(msg)
-		if err != nil {
-			t.Fatalf("failed to marshal JSON: %v", err)
-		}
-
-		if !bytes.Contains(jsonData, []byte("markdown")) {
-			t.Error("JSON should contain 'markdown' field")
-		}
-	})
-
-	t.Run("WeComAccessTokenResponse structure", func(t *testing.T) {
-		jsonData := `{
-			"errcode": 0,
-			"errmsg": "ok",
-			"access_token": "test_access_token",
-			"expires_in": 7200
-		}`
-
-		var resp WeComAccessTokenResponse
-		err := json.Unmarshal([]byte(jsonData), &resp)
-		if err != nil {
-			t.Fatalf("failed to unmarshal JSON: %v", err)
-		}
-
-		if resp.ErrCode != 0 {
-			t.Errorf("ErrCode = %d, want %d", resp.ErrCode, 0)
-		}
-		if resp.ErrMsg != "ok" {
-			t.Errorf("ErrMsg = %q, want %q", resp.ErrMsg, "ok")
-		}
-		if resp.AccessToken != "test_access_token" {
-			t.Errorf("AccessToken = %q, want %q", resp.AccessToken, "test_access_token")
-		}
-		if resp.ExpiresIn != 7200 {
-			t.Errorf("ExpiresIn = %d, want %d", resp.ExpiresIn, 7200)
-		}
-	})
-
-	t.Run("WeComSendMessageResponse structure", func(t *testing.T) {
-		jsonData := `{
-			"errcode": 0,
-			"errmsg": "ok",
-			"invaliduser": "",
-			"invalidparty": "",
-			"invalidtag": ""
-		}`
-
-		var resp WeComSendMessageResponse
-		err := json.Unmarshal([]byte(jsonData), &resp)
-		if err != nil {
-			t.Fatalf("failed to unmarshal JSON: %v", err)
-		}
-
-		if resp.ErrCode != 0 {
-			t.Errorf("ErrCode = %d, want %d", resp.ErrCode, 0)
-		}
-		if resp.ErrMsg != "ok" {
-			t.Errorf("ErrMsg = %q, want %q", resp.ErrMsg, "ok")
-		}
-	})
-}
-
-func TestWeComAppXMLMessageStructure(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[text]]></MsgType>
-	<Content><![CDATA[Hello World]]></Content>
-	<MsgId>1234567890123456</MsgId>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.ToUserName != "corp_id" {
-		t.Errorf("ToUserName = %q, want %q", msg.ToUserName, "corp_id")
-	}
-	if msg.FromUserName != "user123" {
-		t.Errorf("FromUserName = %q, want %q", msg.FromUserName, "user123")
-	}
-	if msg.CreateTime != 1234567890 {
-		t.Errorf("CreateTime = %d, want %d", msg.CreateTime, 1234567890)
-	}
-	if msg.MsgType != "text" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
-	}
-	if msg.Content != "Hello World" {
-		t.Errorf("Content = %q, want %q", msg.Content, "Hello World")
-	}
-	if msg.MsgId != 1234567890123456 {
-		t.Errorf("MsgId = %d, want %d", msg.MsgId, 1234567890123456)
-	}
-	if msg.AgentID != 1000002 {
-		t.Errorf("AgentID = %d, want %d", msg.AgentID, 1000002)
-	}
-}
-
-func TestWeComAppXMLMessageImage(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[image]]></MsgType>
-	<PicUrl><![CDATA[https://example.com/image.jpg]]></PicUrl>
-	<MediaId><![CDATA[media_123]]></MediaId>
-	<MsgId>1234567890123456</MsgId>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.MsgType != "image" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "image")
-	}
-	if msg.PicUrl != "https://example.com/image.jpg" {
-		t.Errorf("PicUrl = %q, want %q", msg.PicUrl, "https://example.com/image.jpg")
-	}
-	if msg.MediaId != "media_123" {
-		t.Errorf("MediaId = %q, want %q", msg.MediaId, "media_123")
-	}
-}
-
-func TestWeComAppXMLMessageVoice(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[voice]]></MsgType>
-	<MediaId><![CDATA[media_123]]></MediaId>
-	<Format><![CDATA[amr]]></Format>
-	<MsgId>1234567890123456</MsgId>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.MsgType != "voice" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "voice")
-	}
-	if msg.Format != "amr" {
-		t.Errorf("Format = %q, want %q", msg.Format, "amr")
-	}
-}
-
-func TestWeComAppXMLMessageLocation(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[location]]></MsgType>
-	<Location_X>39.9042</Location_X>
-	<Location_Y>116.4074</Location_Y>
-	<Scale>16</Scale>
-	<Label><![CDATA[Beijing]]></Label>
-	<MsgId>1234567890123456</MsgId>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.MsgType != "location" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "location")
-	}
-	if msg.LocationX != 39.9042 {
-		t.Errorf("LocationX = %f, want %f", msg.LocationX, 39.9042)
-	}
-	if msg.LocationY != 116.4074 {
-		t.Errorf("LocationY = %f, want %f", msg.LocationY, 116.4074)
-	}
-	if msg.Scale != 16 {
-		t.Errorf("Scale = %d, want %d", msg.Scale, 16)
-	}
-	if msg.Label != "Beijing" {
-		t.Errorf("Label = %q, want %q", msg.Label, "Beijing")
-	}
-}
-
-func TestWeComAppXMLMessageLink(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[link]]></MsgType>
-	<Title><![CDATA[Link Title]]></Title>
-	<Description><![CDATA[Link Description]]></Description>
-	<Url><![CDATA[https://example.com]]></Url>
-	<MsgId>1234567890123456</MsgId>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.MsgType != "link" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "link")
-	}
-	if msg.Title != "Link Title" {
-		t.Errorf("Title = %q, want %q", msg.Title, "Link Title")
-	}
-	if msg.Description != "Link Description" {
-		t.Errorf("Description = %q, want %q", msg.Description, "Link Description")
-	}
-	if msg.Url != "https://example.com" {
-		t.Errorf("Url = %q, want %q", msg.Url, "https://example.com")
-	}
-}
-
-func TestWeComAppXMLMessageEvent(t *testing.T) {
-	xmlData := `<?xml version="1.0"?>
-<xml>
-	<ToUserName><![CDATA[corp_id]]></ToUserName>
-	<FromUserName><![CDATA[user123]]></FromUserName>
-	<CreateTime>1234567890</CreateTime>
-	<MsgType><![CDATA[event]]></MsgType>
-	<Event><![CDATA[subscribe]]></Event>
-	<EventKey><![CDATA[event_key_123]]></EventKey>
-	<AgentID>1000002</AgentID>
-</xml>`
-
-	var msg WeComXMLMessage
-	err := xml.Unmarshal([]byte(xmlData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal XML: %v", err)
-	}
-
-	if msg.MsgType != "event" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "event")
-	}
-	if msg.Event != "subscribe" {
-		t.Errorf("Event = %q, want %q", msg.Event, "subscribe")
-	}
-	if msg.EventKey != "event_key_123" {
-		t.Errorf("EventKey = %q, want %q", msg.EventKey, "event_key_123")
-	}
-}
diff --git a/pkg/channels/wecom_test.go b/pkg/channels/wecom_test.go
deleted file mode 100644
index 8afa7e8c3..000000000
--- a/pkg/channels/wecom_test.go
+++ /dev/null
@@ -1,785 +0,0 @@
-// PicoClaw - Ultra-lightweight personal AI agent
-// WeCom Bot (企业微信智能机器人) channel tests
-
-package channels
-
-import (
-	"bytes"
-	"context"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/sha1"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-// generateTestAESKey generates a valid test AES key
-func generateTestAESKey() string {
-	// AES key needs to be 32 bytes (256 bits) for AES-256
-	key := make([]byte, 32)
-	for i := range key {
-		key[i] = byte(i)
-	}
-	// Return base64 encoded key without padding
-	return base64.StdEncoding.EncodeToString(key)[:43]
-}
-
-// encryptTestMessage encrypts a message for testing (AIBOT JSON format)
-func encryptTestMessage(message, aesKey string) (string, error) {
-	// Decode AES key
-	key, err := base64.StdEncoding.DecodeString(aesKey + "=")
-	if err != nil {
-		return "", err
-	}
-
-	// Prepare message: random(16) + msg_len(4) + msg + receiveid
-	random := make([]byte, 0, 16)
-	for i := 0; i < 16; i++ {
-		random = append(random, byte(i))
-	}
-
-	msgBytes := []byte(message)
-	receiveID := []byte("test_aibot_id")
-
-	msgLen := uint32(len(msgBytes))
-	lenBytes := make([]byte, 4)
-	binary.BigEndian.PutUint32(lenBytes, msgLen)
-
-	plainText := append(random, lenBytes...)
-	plainText = append(plainText, msgBytes...)
-	plainText = append(plainText, receiveID...)
-
-	// PKCS7 padding
-	blockSize := aes.BlockSize
-	padding := blockSize - len(plainText)%blockSize
-	padText := bytes.Repeat([]byte{byte(padding)}, padding)
-	plainText = append(plainText, padText...)
-
-	// Encrypt
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return "", err
-	}
-
-	mode := cipher.NewCBCEncrypter(block, key[:aes.BlockSize])
-	cipherText := make([]byte, len(plainText))
-	mode.CryptBlocks(cipherText, plainText)
-
-	return base64.StdEncoding.EncodeToString(cipherText), nil
-}
-
-// generateSignature generates a signature for testing
-func generateSignature(token, timestamp, nonce, msgEncrypt string) string {
-	params := []string{token, timestamp, nonce, msgEncrypt}
-	sort.Strings(params)
-	str := strings.Join(params, "")
-	hash := sha1.Sum([]byte(str))
-	return fmt.Sprintf("%x", hash)
-}
-
-func TestNewWeComBotChannel(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("missing token", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:      "",
-			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-		}
-		_, err := NewWeComBotChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing token, got nil")
-		}
-	})
-
-	t.Run("missing webhook_url", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:      "test_token",
-			WebhookURL: "",
-		}
-		_, err := NewWeComBotChannel(cfg, msgBus)
-		if err == nil {
-			t.Error("expected error for missing webhook_url, got nil")
-		}
-	})
-
-	t.Run("valid config", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:      "test_token",
-			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			AllowFrom:  []string{"user1", "user2"},
-		}
-		ch, err := NewWeComBotChannel(cfg, msgBus)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if ch.Name() != "wecom" {
-			t.Errorf("Name() = %q, want %q", ch.Name(), "wecom")
-		}
-		if ch.IsRunning() {
-			t.Error("new channel should not be running")
-		}
-	})
-}
-
-func TestWeComBotChannelIsAllowed(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("empty allowlist allows all", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:      "test_token",
-			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			AllowFrom:  []string{},
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-		if !ch.IsAllowed("any_user") {
-			t.Error("empty allowlist should allow all users")
-		}
-	})
-
-	t.Run("allowlist restricts users", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:      "test_token",
-			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			AllowFrom:  []string{"allowed_user"},
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-		if !ch.IsAllowed("allowed_user") {
-			t.Error("allowed user should pass allowlist check")
-		}
-		if ch.IsAllowed("blocked_user") {
-			t.Error("non-allowed user should be blocked")
-		}
-	})
-}
-
-func TestWeComBotVerifySignature(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComConfig{
-		Token:      "test_token",
-		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	t.Run("valid signature", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		msgEncrypt := "test_message"
-		expectedSig := generateSignature("test_token", timestamp, nonce, msgEncrypt)
-
-		if !WeComVerifySignature(ch.config.Token, expectedSig, timestamp, nonce, msgEncrypt) {
-			t.Error("valid signature should pass verification")
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		msgEncrypt := "test_message"
-
-		if WeComVerifySignature(ch.config.Token, "invalid_sig", timestamp, nonce, msgEncrypt) {
-			t.Error("invalid signature should fail verification")
-		}
-	})
-
-	t.Run("empty token skips verification", func(t *testing.T) {
-		// Create a channel manually with empty token to test the behavior
-		cfgEmpty := config.WeComConfig{
-			Token:      "",
-			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-		}
-		chEmpty := &WeComBotChannel{
-			config: cfgEmpty,
-		}
-
-		if !WeComVerifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
-			t.Error("empty token should skip verification and return true")
-		}
-	})
-}
-
-func TestWeComBotDecryptMessage(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-
-	t.Run("decrypt without AES key", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:          "test_token",
-			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			EncodingAESKey: "",
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-		// Without AES key, message should be base64 decoded only
-		plainText := "hello world"
-		encoded := base64.StdEncoding.EncodeToString([]byte(plainText))
-
-		result, err := WeComDecryptMessage(encoded, ch.config.EncodingAESKey)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if result != plainText {
-			t.Errorf("decryptMessage() = %q, want %q", result, plainText)
-		}
-	})
-
-	t.Run("decrypt with AES key", func(t *testing.T) {
-		aesKey := generateTestAESKey()
-		cfg := config.WeComConfig{
-			Token:          "test_token",
-			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			EncodingAESKey: aesKey,
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-		originalMsg := "<xml><Content>Hello</Content></xml>"
-		encrypted, err := encryptTestMessage(originalMsg, aesKey)
-		if err != nil {
-			t.Fatalf("failed to encrypt test message: %v", err)
-		}
-
-		result, err := WeComDecryptMessage(encrypted, ch.config.EncodingAESKey)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if result != originalMsg {
-			t.Errorf("WeComDecryptMessage() = %q, want %q", result, originalMsg)
-		}
-	})
-
-	t.Run("invalid base64", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:          "test_token",
-			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			EncodingAESKey: "",
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-		_, err := WeComDecryptMessage("invalid_base64!!!", ch.config.EncodingAESKey)
-		if err == nil {
-			t.Error("expected error for invalid base64, got nil")
-		}
-	})
-
-	t.Run("invalid AES key", func(t *testing.T) {
-		cfg := config.WeComConfig{
-			Token:          "test_token",
-			WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			EncodingAESKey: "invalid_key",
-		}
-		ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-		_, err := WeComDecryptMessage(base64.StdEncoding.EncodeToString([]byte("test")), ch.config.EncodingAESKey)
-		if err == nil {
-			t.Error("expected error for invalid AES key, got nil")
-		}
-	})
-}
-
-func TestWeComBotPKCS7Unpad(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    []byte
-		expected []byte
-	}{
-		{
-			name:     "empty input",
-			input:    []byte{},
-			expected: []byte{},
-		},
-		{
-			name:     "valid padding 3 bytes",
-			input:    append([]byte("hello"), bytes.Repeat([]byte{3}, 3)...),
-			expected: []byte("hello"),
-		},
-		{
-			name:     "valid padding 16 bytes (full block)",
-			input:    append([]byte("123456789012345"), bytes.Repeat([]byte{16}, 16)...),
-			expected: []byte("123456789012345"),
-		},
-		{
-			name:     "invalid padding larger than data",
-			input:    []byte{20},
-			expected: nil, // should return error
-		},
-		{
-			name:     "invalid padding zero",
-			input:    append([]byte("test"), byte(0)),
-			expected: nil, // should return error
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := pkcs7UnpadWeCom(tt.input)
-			if tt.expected == nil {
-				// This case should return an error
-				if err == nil {
-					t.Errorf("pkcs7UnpadWeCom() expected error for invalid padding, got result: %v", result)
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("pkcs7UnpadWeCom() unexpected error: %v", err)
-				return
-			}
-			if !bytes.Equal(result, tt.expected) {
-				t.Errorf("pkcs7UnpadWeCom() = %v, want %v", result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestWeComBotHandleVerification(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	aesKey := generateTestAESKey()
-	cfg := config.WeComConfig{
-		Token:          "test_token",
-		EncodingAESKey: aesKey,
-		WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	t.Run("valid verification request", func(t *testing.T) {
-		echostr := "test_echostr_123"
-		encryptedEchostr, _ := encryptTestMessage(echostr, aesKey)
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, encryptedEchostr)
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-		if w.Body.String() != echostr {
-			t.Errorf("response body = %q, want %q", w.Body.String(), echostr)
-		}
-	})
-
-	t.Run("missing parameters", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature=sig&timestamp=ts", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		echostr := "test_echostr"
-		encryptedEchostr, _ := encryptTestMessage(echostr, aesKey)
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleVerification(context.Background(), w, req)
-
-		if w.Code != http.StatusForbidden {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
-		}
-	})
-}
-
-func TestWeComBotHandleMessageCallback(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	aesKey := generateTestAESKey()
-	cfg := config.WeComConfig{
-		Token:          "test_token",
-		EncodingAESKey: aesKey,
-		WebhookURL:     "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	t.Run("valid direct message callback", func(t *testing.T) {
-		// Create JSON message for direct chat (single)
-		jsonMsg := `{
-			"msgid": "test_msg_id_123",
-			"aibotid": "test_aibot_id",
-			"chattype": "single",
-			"from": {"userid": "user123"},
-			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			"msgtype": "text",
-			"text": {"content": "Hello World"}
-		}`
-
-		// Encrypt message
-		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
-
-		// Create encrypted XML wrapper
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: encrypted,
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, encrypted)
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-		if w.Body.String() != "success" {
-			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
-		}
-	})
-
-	t.Run("valid group message callback", func(t *testing.T) {
-		// Create JSON message for group chat
-		jsonMsg := `{
-			"msgid": "test_msg_id_456",
-			"aibotid": "test_aibot_id",
-			"chatid": "group_chat_id_123",
-			"chattype": "group",
-			"from": {"userid": "user456"},
-			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			"msgtype": "text",
-			"text": {"content": "Hello Group"}
-		}`
-
-		// Encrypt message
-		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
-
-		// Create encrypted XML wrapper
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: encrypted,
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, encrypted)
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-		if w.Body.String() != "success" {
-			t.Errorf("response body = %q, want %q", w.Body.String(), "success")
-		}
-	})
-
-	t.Run("missing parameters", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature=sig", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid XML", func(t *testing.T) {
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, "")
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			strings.NewReader("invalid xml"),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusBadRequest {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusBadRequest)
-		}
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: "encrypted_data",
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleMessageCallback(context.Background(), w, req)
-
-		if w.Code != http.StatusForbidden {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusForbidden)
-		}
-	})
-}
-
-func TestWeComBotProcessMessage(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComConfig{
-		Token:      "test_token",
-		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	t.Run("process direct text message", func(t *testing.T) {
-		msg := WeComBotMessage{
-			MsgID:       "test_msg_id_123",
-			AIBotID:     "test_aibot_id",
-			ChatType:    "single",
-			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			MsgType:     "text",
-		}
-		msg.From.UserID = "user123"
-		msg.Text.Content = "Hello World"
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("process group text message", func(t *testing.T) {
-		msg := WeComBotMessage{
-			MsgID:       "test_msg_id_456",
-			AIBotID:     "test_aibot_id",
-			ChatID:      "group_chat_id_123",
-			ChatType:    "group",
-			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			MsgType:     "text",
-		}
-		msg.From.UserID = "user456"
-		msg.Text.Content = "Hello Group"
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("process voice message", func(t *testing.T) {
-		msg := WeComBotMessage{
-			MsgID:       "test_msg_id_789",
-			AIBotID:     "test_aibot_id",
-			ChatType:    "single",
-			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			MsgType:     "voice",
-		}
-		msg.From.UserID = "user123"
-		msg.Voice.Content = "Voice message text"
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-
-	t.Run("skip unsupported message type", func(t *testing.T) {
-		msg := WeComBotMessage{
-			MsgID:       "test_msg_id_000",
-			AIBotID:     "test_aibot_id",
-			ChatType:    "single",
-			ResponseURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			MsgType:     "video",
-		}
-		msg.From.UserID = "user123"
-
-		// Should not panic
-		ch.processMessage(context.Background(), msg)
-	})
-}
-
-func TestWeComBotHandleWebhook(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComConfig{
-		Token:      "test_token",
-		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	t.Run("GET request calls verification", func(t *testing.T) {
-		echostr := "test_echostr"
-		encoded := base64.StdEncoding.EncodeToString([]byte(echostr))
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, encoded)
-
-		req := httptest.NewRequest(
-			http.MethodGet,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded,
-			nil,
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		if w.Code != http.StatusOK {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-		}
-	})
-
-	t.Run("POST request calls message callback", func(t *testing.T) {
-		encryptedWrapper := struct {
-			XMLName xml.Name `xml:"xml"`
-			Encrypt string   `xml:"Encrypt"`
-		}{
-			Encrypt: base64.StdEncoding.EncodeToString([]byte("test")),
-		}
-		wrapperData, _ := xml.Marshal(encryptedWrapper)
-
-		timestamp := "1234567890"
-		nonce := "test_nonce"
-		signature := generateSignature("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
-
-		req := httptest.NewRequest(
-			http.MethodPost,
-			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
-			bytes.NewReader(wrapperData),
-		)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		// Should not be method not allowed
-		if w.Code == http.StatusMethodNotAllowed {
-			t.Error("POST request should not return Method Not Allowed")
-		}
-	})
-
-	t.Run("unsupported method", func(t *testing.T) {
-		req := httptest.NewRequest(http.MethodPut, "/webhook/wecom", nil)
-		w := httptest.NewRecorder()
-
-		ch.handleWebhook(w, req)
-
-		if w.Code != http.StatusMethodNotAllowed {
-			t.Errorf("status code = %d, want %d", w.Code, http.StatusMethodNotAllowed)
-		}
-	})
-}
-
-func TestWeComBotHandleHealth(t *testing.T) {
-	msgBus := bus.NewMessageBus()
-	cfg := config.WeComConfig{
-		Token:      "test_token",
-		WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-	}
-	ch, _ := NewWeComBotChannel(cfg, msgBus)
-
-	req := httptest.NewRequest(http.MethodGet, "/health/wecom", nil)
-	w := httptest.NewRecorder()
-
-	ch.handleHealth(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("status code = %d, want %d", w.Code, http.StatusOK)
-	}
-
-	contentType := w.Header().Get("Content-Type")
-	if contentType != "application/json" {
-		t.Errorf("Content-Type = %q, want %q", contentType, "application/json")
-	}
-
-	body := w.Body.String()
-	if !strings.Contains(body, "status") || !strings.Contains(body, "running") {
-		t.Errorf("response body should contain status and running fields, got: %s", body)
-	}
-}
-
-func TestWeComBotReplyMessage(t *testing.T) {
-	msg := WeComBotReplyMessage{
-		MsgType: "text",
-	}
-	msg.Text.Content = "Hello World"
-
-	if msg.MsgType != "text" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
-	}
-	if msg.Text.Content != "Hello World" {
-		t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
-	}
-}
-
-func TestWeComBotMessageStructure(t *testing.T) {
-	jsonData := `{
-		"msgid": "test_msg_id_123",
-		"aibotid": "test_aibot_id",
-		"chatid": "group_chat_id_123",
-		"chattype": "group",
-		"from": {"userid": "user123"},
-		"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-		"msgtype": "text",
-		"text": {"content": "Hello World"}
-	}`
-
-	var msg WeComBotMessage
-	err := json.Unmarshal([]byte(jsonData), &msg)
-	if err != nil {
-		t.Fatalf("failed to unmarshal JSON: %v", err)
-	}
-
-	if msg.MsgID != "test_msg_id_123" {
-		t.Errorf("MsgID = %q, want %q", msg.MsgID, "test_msg_id_123")
-	}
-	if msg.AIBotID != "test_aibot_id" {
-		t.Errorf("AIBotID = %q, want %q", msg.AIBotID, "test_aibot_id")
-	}
-	if msg.ChatID != "group_chat_id_123" {
-		t.Errorf("ChatID = %q, want %q", msg.ChatID, "group_chat_id_123")
-	}
-	if msg.ChatType != "group" {
-		t.Errorf("ChatType = %q, want %q", msg.ChatType, "group")
-	}
-	if msg.From.UserID != "user123" {
-		t.Errorf("From.UserID = %q, want %q", msg.From.UserID, "user123")
-	}
-	if msg.MsgType != "text" {
-		t.Errorf("MsgType = %q, want %q", msg.MsgType, "text")
-	}
-	if msg.Text.Content != "Hello World" {
-		t.Errorf("Text.Content = %q, want %q", msg.Text.Content, "Hello World")
-	}
-}
diff --git a/pkg/channels/whatsapp.go b/pkg/channels/whatsapp.go
deleted file mode 100644
index 958d850bb..000000000
--- a/pkg/channels/whatsapp.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package channels
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-
-	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/utils"
-)
-
-type WhatsAppChannel struct {
-	*BaseChannel
-	conn      *websocket.Conn
-	config    config.WhatsAppConfig
-	url       string
-	mu        sync.Mutex
-	connected bool
-}
-
-func NewWhatsAppChannel(cfg config.WhatsAppConfig, bus *bus.MessageBus) (*WhatsAppChannel, error) {
-	base := NewBaseChannel("whatsapp", cfg, bus, cfg.AllowFrom)
-
-	return &WhatsAppChannel{
-		BaseChannel: base,
-		config:      cfg,
-		url:         cfg.BridgeURL,
-		connected:   false,
-	}, nil
-}
-
-func (c *WhatsAppChannel) Start(ctx context.Context) error {
-	log.Printf("Starting WhatsApp channel connecting to %s...", c.url)
-
-	dialer := websocket.DefaultDialer
-	dialer.HandshakeTimeout = 10 * time.Second
-
-	conn, _, err := dialer.Dial(c.url, nil)
-	if err != nil {
-		return fmt.Errorf("failed to connect to WhatsApp bridge: %w", err)
-	}
-
-	c.mu.Lock()
-	c.conn = conn
-	c.connected = true
-	c.mu.Unlock()
-
-	c.setRunning(true)
-	log.Println("WhatsApp channel connected")
-
-	go c.listen(ctx)
-
-	return nil
-}
-
-func (c *WhatsAppChannel) Stop(ctx context.Context) error {
-	log.Println("Stopping WhatsApp channel...")
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.conn != nil {
-		if err := c.conn.Close(); err != nil {
-			log.Printf("Error closing WhatsApp connection: %v", err)
-		}
-		c.conn = nil
-	}
-
-	c.connected = false
-	c.setRunning(false)
-
-	return nil
-}
-
-func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.conn == nil {
-		return fmt.Errorf("whatsapp connection not established")
-	}
-
-	payload := map[string]any{
-		"type":    "message",
-		"to":      msg.ChatID,
-		"content": msg.Content,
-	}
-
-	data, err := json.Marshal(payload)
-	if err != nil {
-		return fmt.Errorf("failed to marshal message: %w", err)
-	}
-
-	if err := c.conn.WriteMessage(websocket.TextMessage, data); err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
-	}
-
-	return nil
-}
-
-func (c *WhatsAppChannel) listen(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			c.mu.Lock()
-			conn := c.conn
-			c.mu.Unlock()
-
-			if conn == nil {
-				time.Sleep(1 * time.Second)
-				continue
-			}
-
-			_, message, err := conn.ReadMessage()
-			if err != nil {
-				log.Printf("WhatsApp read error: %v", err)
-				time.Sleep(2 * time.Second)
-				continue
-			}
-
-			var msg map[string]any
-			if err := json.Unmarshal(message, &msg); err != nil {
-				log.Printf("Failed to unmarshal WhatsApp message: %v", err)
-				continue
-			}
-
-			msgType, ok := msg["type"].(string)
-			if !ok {
-				continue
-			}
-
-			if msgType == "message" {
-				c.handleIncomingMessage(msg)
-			}
-		}
-	}
-}
-
-func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
-	senderID, ok := msg["from"].(string)
-	if !ok {
-		return
-	}
-
-	chatID, ok := msg["chat"].(string)
-	if !ok {
-		chatID = senderID
-	}
-
-	content, ok := msg["content"].(string)
-	if !ok {
-		content = ""
-	}
-
-	var mediaPaths []string
-	if mediaData, ok := msg["media"].([]any); ok {
-		mediaPaths = make([]string, 0, len(mediaData))
-		for _, m := range mediaData {
-			if path, ok := m.(string); ok {
-				mediaPaths = append(mediaPaths, path)
-			}
-		}
-	}
-
-	metadata := make(map[string]string)
-	if messageID, ok := msg["id"].(string); ok {
-		metadata["message_id"] = messageID
-	}
-	if userName, ok := msg["from_name"].(string); ok {
-		metadata["user_name"] = userName
-	}
-
-	if chatID == senderID {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
-	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
-	}
-
-	log.Printf("WhatsApp message from %s: %s...", senderID, utils.Truncate(content, 50))
-
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
-}

From 420eadc2ba3051e3b00c228fc14d7f12ecfcb24b Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Fri, 20 Feb 2026 23:52:41 +0800
Subject: [PATCH 31/52] refactor(channels): remove redundant setRunning method
 from BaseChannel

---
 pkg/channels/base.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index 3f0a766ea..ff734fdb0 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -98,10 +98,6 @@ func (c *BaseChannel) HandleMessage(senderID, chatID, content string, media []st
 	c.bus.PublishInbound(msg)
 }
 
-func (c *BaseChannel) setRunning(running bool) {
-	c.running = running
-}
-
 func (c *BaseChannel) SetRunning(running bool) {
 	c.running = running
 }

From b1cbaaba570b1276a4109724a039c8232d2bc437 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sat, 21 Feb 2026 00:00:29 +0800
Subject: [PATCH 32/52] refactor(channels): replace bool with atomic.Bool for
 running state in BaseChannel

---
 pkg/channels/base.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index ff734fdb0..5d77c6c0d 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -3,6 +3,7 @@ package channels
 import (
 	"context"
 	"strings"
+	"sync/atomic"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 )
@@ -19,7 +20,7 @@ type Channel interface {
 type BaseChannel struct {
 	config    any
 	bus       *bus.MessageBus
-	running   bool
+	running   atomic.Bool
 	name      string
 	allowList []string
 }
@@ -30,7 +31,6 @@ func NewBaseChannel(name string, config any, bus *bus.MessageBus, allowList []st
 		bus:       bus,
 		name:      name,
 		allowList: allowList,
-		running:   false,
 	}
 }
 
@@ -39,7 +39,7 @@ func (c *BaseChannel) Name() string {
 }
 
 func (c *BaseChannel) IsRunning() bool {
-	return c.running
+	return c.running.Load()
 }
 
 func (c *BaseChannel) IsAllowed(senderID string) bool {
@@ -99,5 +99,5 @@ func (c *BaseChannel) HandleMessage(senderID, chatID, content string, media []st
 }
 
 func (c *BaseChannel) SetRunning(running bool) {
-	c.running = running
+	c.running.Store(running)
 }

From 00fd70e1aa2e3068b8caa27db13666be76154985 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sat, 21 Feb 2026 16:35:56 +0800
Subject: [PATCH 33/52] fix: golangci-lint run --fix

---
 cmd/picoclaw/cmd_gateway.go                |  22 ++---
 pkg/channels/dingtalk/dingtalk.go          |  13 ++-
 pkg/channels/discord/discord.go            |   5 +-
 pkg/channels/feishu/feishu_64.go           |   6 +-
 pkg/channels/line/line.go                  |  36 +++----
 pkg/channels/maixcam/maixcam.go            |  26 ++---
 pkg/channels/manager.go                    |  28 +++---
 pkg/channels/onebot/onebot.go              |  91 +++++++++---------
 pkg/channels/qq/qq.go                      |  10 +-
 pkg/channels/slack/slack.go                |  22 ++---
 pkg/channels/telegram/telegram.go          |  36 +++----
 pkg/channels/telegram/telegram_commands.go |   3 +
 pkg/channels/wecom/app.go                  |  40 ++++----
 pkg/channels/wecom/app_test.go             |  73 ++++++++++----
 pkg/channels/wecom/bot.go                  |  27 +++---
 pkg/channels/wecom/bot_test.go             | 105 +++++++++++++--------
 pkg/channels/whatsapp/whatsapp.go          |   8 +-
 17 files changed, 315 insertions(+), 236 deletions(-)

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 29b31e071..c62c868e3 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -16,9 +16,17 @@ import (
 	"github.com/sipeed/picoclaw/pkg/agent"
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
+	_ "github.com/sipeed/picoclaw/pkg/channels/dingtalk"
 	dch "github.com/sipeed/picoclaw/pkg/channels/discord"
+	_ "github.com/sipeed/picoclaw/pkg/channels/feishu"
+	_ "github.com/sipeed/picoclaw/pkg/channels/line"
+	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
+	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
+	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
 	slackch "github.com/sipeed/picoclaw/pkg/channels/slack"
-	tgram "github.com/sipeed/picoclaw/pkg/channels/telegram"
+	tgramch "github.com/sipeed/picoclaw/pkg/channels/telegram"
+	_ "github.com/sipeed/picoclaw/pkg/channels/wecom"
+	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/cron"
 	"github.com/sipeed/picoclaw/pkg/devices"
@@ -29,16 +37,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
 	"github.com/sipeed/picoclaw/pkg/voice"
-
-	// Channel factory registrations (blank imports trigger init())
-	_ "github.com/sipeed/picoclaw/pkg/channels/dingtalk"
-	_ "github.com/sipeed/picoclaw/pkg/channels/feishu"
-	_ "github.com/sipeed/picoclaw/pkg/channels/line"
-	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
-	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
-	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
-	_ "github.com/sipeed/picoclaw/pkg/channels/wecom"
-	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp"
 )
 
 func gatewayCmd() {
@@ -151,7 +149,7 @@ func gatewayCmd() {
 
 	if transcriber != nil {
 		if telegramChannel, ok := channelManager.GetChannel("telegram"); ok {
-			if tc, ok := telegramChannel.(*tgram.TelegramChannel); ok {
+			if tc, ok := telegramChannel.(*tgramch.TelegramChannel); ok {
 				tc.SetTranscriber(transcriber)
 				logger.InfoC("voice", "Groq transcription attached to Telegram channel")
 			}
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index 0edb0023c..afc0de47f 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -10,6 +10,7 @@ import (
 
 	"github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot"
 	"github.com/open-dingtalk/dingtalk-stream-sdk-go/client"
+
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
@@ -109,7 +110,7 @@ func (c *DingTalkChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("invalid session_webhook type for chat %s", msg.ChatID)
 	}
 
-	logger.DebugCF("dingtalk", "Sending message", map[string]interface{}{
+	logger.DebugCF("dingtalk", "Sending message", map[string]any{
 		"chat_id": msg.ChatID,
 		"preview": utils.Truncate(msg.Content, 100),
 	})
@@ -121,12 +122,15 @@ func (c *DingTalkChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 // onChatBotMessageReceived implements the IChatBotMessageHandler function signature
 // This is called by the Stream SDK when a new message arrives
 // IChatBotMessageHandler is: func(c context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error)
-func (c *DingTalkChannel) onChatBotMessageReceived(ctx context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error) {
+func (c *DingTalkChannel) onChatBotMessageReceived(
+	ctx context.Context,
+	data *chatbot.BotCallbackDataModel,
+) ([]byte, error) {
 	// Extract message content from Text field
 	content := data.Text.Content
 	if content == "" {
 		// Try to extract from Content interface{} if Text is empty
-		if contentMap, ok := data.Content.(map[string]interface{}); ok {
+		if contentMap, ok := data.Content.(map[string]any); ok {
 			if textContent, ok := contentMap["content"].(string); ok {
 				content = textContent
 			}
@@ -164,7 +168,7 @@ func (c *DingTalkChannel) onChatBotMessageReceived(ctx context.Context, data *ch
 		metadata["peer_id"] = data.ConversationId
 	}
 
-	logger.DebugCF("dingtalk", "Received message", map[string]interface{}{
+	logger.DebugCF("dingtalk", "Received message", map[string]any{
 		"sender_nick": senderNick,
 		"sender_id":   senderID,
 		"preview":     utils.Truncate(content, 50),
@@ -193,7 +197,6 @@ func (c *DingTalkChannel) SendDirectReply(ctx context.Context, sessionWebhook, c
 		titleBytes,
 		contentBytes,
 	)
-
 	if err != nil {
 		return fmt.Errorf("failed to send reply: %w", err)
 	}
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 6c4efd87c..b83ac28fd 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/bwmarrin/discordgo"
+
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
@@ -322,7 +323,7 @@ func (c *DiscordChannel) startTyping(chatID string) {
 
 	go func() {
 		if err := c.session.ChannelTyping(chatID); err != nil {
-			logger.DebugCF("discord", "ChannelTyping error", map[string]interface{}{"chatID": chatID, "err": err})
+			logger.DebugCF("discord", "ChannelTyping error", map[string]any{"chatID": chatID, "err": err})
 		}
 		ticker := time.NewTicker(8 * time.Second)
 		defer ticker.Stop()
@@ -337,7 +338,7 @@ func (c *DiscordChannel) startTyping(chatID string) {
 				return
 			case <-ticker.C:
 				if err := c.session.ChannelTyping(chatID); err != nil {
-					logger.DebugCF("discord", "ChannelTyping error", map[string]interface{}{"chatID": chatID, "err": err})
+					logger.DebugCF("discord", "ChannelTyping error", map[string]any{"chatID": chatID, "err": err})
 				}
 			}
 		}
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index a49ee34cb..aa4e141c4 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -66,7 +66,7 @@ func (c *FeishuChannel) Start(ctx context.Context) error {
 
 	go func() {
 		if err := wsClient.Start(runCtx); err != nil {
-			logger.ErrorCF("feishu", "Feishu websocket stopped with error", map[string]interface{}{
+			logger.ErrorCF("feishu", "Feishu websocket stopped with error", map[string]any{
 				"error": err.Error(),
 			})
 		}
@@ -122,7 +122,7 @@ func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 		return fmt.Errorf("feishu api error: code=%d msg=%s", resp.Code, resp.Msg)
 	}
 
-	logger.DebugCF("feishu", "Feishu message sent", map[string]interface{}{
+	logger.DebugCF("feishu", "Feishu message sent", map[string]any{
 		"chat_id": msg.ChatID,
 	})
 
@@ -175,7 +175,7 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 		metadata["peer_id"] = chatID
 	}
 
-	logger.InfoCF("feishu", "Feishu message received", map[string]interface{}{
+	logger.InfoCF("feishu", "Feishu message received", map[string]any{
 		"sender_id": senderID,
 		"chat_id":   chatID,
 		"preview":   utils.Truncate(content, 80),
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 7df0491d9..4e1d0dfd3 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -76,11 +76,11 @@ func (c *LINEChannel) Start(ctx context.Context) error {
 
 	// Fetch bot profile to get bot's userId for mention detection
 	if err := c.fetchBotInfo(); err != nil {
-		logger.WarnCF("line", "Failed to fetch bot info (mention detection disabled)", map[string]interface{}{
+		logger.WarnCF("line", "Failed to fetch bot info (mention detection disabled)", map[string]any{
 			"error": err.Error(),
 		})
 	} else {
-		logger.InfoCF("line", "Bot info fetched", map[string]interface{}{
+		logger.InfoCF("line", "Bot info fetched", map[string]any{
 			"bot_user_id":  c.botUserID,
 			"basic_id":     c.botBasicID,
 			"display_name": c.botDisplayName,
@@ -101,12 +101,12 @@ func (c *LINEChannel) Start(ctx context.Context) error {
 	}
 
 	go func() {
-		logger.InfoCF("line", "LINE webhook server listening", map[string]interface{}{
+		logger.InfoCF("line", "LINE webhook server listening", map[string]any{
 			"addr": addr,
 			"path": path,
 		})
 		if err := c.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("line", "Webhook server error", map[string]interface{}{
+			logger.ErrorCF("line", "Webhook server error", map[string]any{
 				"error": err.Error(),
 			})
 		}
@@ -163,7 +163,7 @@ func (c *LINEChannel) Stop(ctx context.Context) error {
 		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
 		defer cancel()
 		if err := c.httpServer.Shutdown(shutdownCtx); err != nil {
-			logger.ErrorCF("line", "Webhook server shutdown error", map[string]interface{}{
+			logger.ErrorCF("line", "Webhook server shutdown error", map[string]any{
 				"error": err.Error(),
 			})
 		}
@@ -183,7 +183,7 @@ func (c *LINEChannel) webhookHandler(w http.ResponseWriter, r *http.Request) {
 
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		logger.ErrorCF("line", "Failed to read request body", map[string]interface{}{
+		logger.ErrorCF("line", "Failed to read request body", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Bad request", http.StatusBadRequest)
@@ -201,7 +201,7 @@ func (c *LINEChannel) webhookHandler(w http.ResponseWriter, r *http.Request) {
 		Events []lineEvent `json:"events"`
 	}
 	if err := json.Unmarshal(body, &payload); err != nil {
-		logger.ErrorCF("line", "Failed to parse webhook payload", map[string]interface{}{
+		logger.ErrorCF("line", "Failed to parse webhook payload", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Bad request", http.StatusBadRequest)
@@ -267,7 +267,7 @@ type lineMentionee struct {
 
 func (c *LINEChannel) processEvent(event lineEvent) {
 	if event.Type != "message" {
-		logger.DebugCF("line", "Ignoring non-message event", map[string]interface{}{
+		logger.DebugCF("line", "Ignoring non-message event", map[string]any{
 			"type": event.Type,
 		})
 		return
@@ -279,7 +279,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 
 	var msg lineMessage
 	if err := json.Unmarshal(event.Message, &msg); err != nil {
-		logger.ErrorCF("line", "Failed to parse message", map[string]interface{}{
+		logger.ErrorCF("line", "Failed to parse message", map[string]any{
 			"error": err.Error(),
 		})
 		return
@@ -287,7 +287,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 
 	// In group chats, only respond when the bot is mentioned
 	if isGroup && !c.isBotMentioned(msg) {
-		logger.DebugCF("line", "Ignoring group message without mention", map[string]interface{}{
+		logger.DebugCF("line", "Ignoring group message without mention", map[string]any{
 			"chat_id": chatID,
 		})
 		return
@@ -313,7 +313,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	defer func() {
 		for _, file := range localFiles {
 			if err := os.Remove(file); err != nil {
-				logger.DebugCF("line", "Failed to cleanup temp file", map[string]interface{}{
+				logger.DebugCF("line", "Failed to cleanup temp file", map[string]any{
 					"file":  file,
 					"error": err.Error(),
 				})
@@ -375,7 +375,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 		metadata["peer_id"] = senderID
 	}
 
-	logger.DebugCF("line", "Received message", map[string]interface{}{
+	logger.DebugCF("line", "Received message", map[string]any{
 		"sender_id":    senderID,
 		"chat_id":      chatID,
 		"message_type": msg.Type,
@@ -506,7 +506,7 @@ func (c *LINEChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 		tokenEntry := entry.(replyTokenEntry)
 		if time.Since(tokenEntry.timestamp) < lineReplyTokenMaxAge {
 			if err := c.sendReply(ctx, tokenEntry.token, msg.Content, quoteToken); err == nil {
-				logger.DebugCF("line", "Message sent via Reply API", map[string]interface{}{
+				logger.DebugCF("line", "Message sent via Reply API", map[string]any{
 					"chat_id": msg.ChatID,
 					"quoted":  quoteToken != "",
 				})
@@ -534,7 +534,7 @@ func buildTextMessage(content, quoteToken string) map[string]string {
 
 // sendReply sends a message using the LINE Reply API.
 func (c *LINEChannel) sendReply(ctx context.Context, replyToken, content, quoteToken string) error {
-	payload := map[string]interface{}{
+	payload := map[string]any{
 		"replyToken": replyToken,
 		"messages":   []map[string]string{buildTextMessage(content, quoteToken)},
 	}
@@ -544,7 +544,7 @@ func (c *LINEChannel) sendReply(ctx context.Context, replyToken, content, quoteT
 
 // sendPush sends a message using the LINE Push API.
 func (c *LINEChannel) sendPush(ctx context.Context, to, content, quoteToken string) error {
-	payload := map[string]interface{}{
+	payload := map[string]any{
 		"to":       to,
 		"messages": []map[string]string{buildTextMessage(content, quoteToken)},
 	}
@@ -554,19 +554,19 @@ func (c *LINEChannel) sendPush(ctx context.Context, to, content, quoteToken stri
 
 // sendLoading sends a loading animation indicator to the chat.
 func (c *LINEChannel) sendLoading(chatID string) {
-	payload := map[string]interface{}{
+	payload := map[string]any{
 		"chatId":         chatID,
 		"loadingSeconds": 60,
 	}
 	if err := c.callAPI(c.ctx, lineLoadingEndpoint, payload); err != nil {
-		logger.DebugCF("line", "Failed to send loading indicator", map[string]interface{}{
+		logger.DebugCF("line", "Failed to send loading indicator", map[string]any{
 			"error": err.Error(),
 		})
 	}
 }
 
 // callAPI makes an authenticated POST request to the LINE API.
-func (c *LINEChannel) callAPI(ctx context.Context, endpoint string, payload interface{}) error {
+func (c *LINEChannel) callAPI(ctx context.Context, endpoint string, payload any) error {
 	body, err := json.Marshal(payload)
 	if err != nil {
 		return fmt.Errorf("failed to marshal payload: %w", err)
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index d3c6662d7..a7bff55e0 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -22,10 +22,10 @@ type MaixCamChannel struct {
 }
 
 type MaixCamMessage struct {
-	Type      string                 `json:"type"`
-	Tips      string                 `json:"tips"`
-	Timestamp float64                `json:"timestamp"`
-	Data      map[string]interface{} `json:"data"`
+	Type      string         `json:"type"`
+	Tips      string         `json:"tips"`
+	Timestamp float64        `json:"timestamp"`
+	Data      map[string]any `json:"data"`
 }
 
 func NewMaixCamChannel(cfg config.MaixCamConfig, bus *bus.MessageBus) (*MaixCamChannel, error) {
@@ -50,7 +50,7 @@ func (c *MaixCamChannel) Start(ctx context.Context) error {
 	c.listener = listener
 	c.SetRunning(true)
 
-	logger.InfoCF("maixcam", "MaixCam server listening", map[string]interface{}{
+	logger.InfoCF("maixcam", "MaixCam server listening", map[string]any{
 		"host": c.config.Host,
 		"port": c.config.Port,
 	})
@@ -72,14 +72,14 @@ func (c *MaixCamChannel) acceptConnections(ctx context.Context) {
 			conn, err := c.listener.Accept()
 			if err != nil {
 				if c.IsRunning() {
-					logger.ErrorCF("maixcam", "Failed to accept connection", map[string]interface{}{
+					logger.ErrorCF("maixcam", "Failed to accept connection", map[string]any{
 						"error": err.Error(),
 					})
 				}
 				return
 			}
 
-			logger.InfoCF("maixcam", "New connection from MaixCam device", map[string]interface{}{
+			logger.InfoCF("maixcam", "New connection from MaixCam device", map[string]any{
 				"remote_addr": conn.RemoteAddr().String(),
 			})
 
@@ -113,7 +113,7 @@ func (c *MaixCamChannel) handleConnection(conn net.Conn, ctx context.Context) {
 			var msg MaixCamMessage
 			if err := decoder.Decode(&msg); err != nil {
 				if err.Error() != "EOF" {
-					logger.ErrorCF("maixcam", "Failed to decode message", map[string]interface{}{
+					logger.ErrorCF("maixcam", "Failed to decode message", map[string]any{
 						"error": err.Error(),
 					})
 				}
@@ -134,14 +134,14 @@ func (c *MaixCamChannel) processMessage(msg MaixCamMessage, conn net.Conn) {
 	case "status":
 		c.handleStatusUpdate(msg)
 	default:
-		logger.WarnCF("maixcam", "Unknown message type", map[string]interface{}{
+		logger.WarnCF("maixcam", "Unknown message type", map[string]any{
 			"type": msg.Type,
 		})
 	}
 }
 
 func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
-	logger.InfoCF("maixcam", "", map[string]interface{}{
+	logger.InfoCF("maixcam", "", map[string]any{
 		"timestamp": msg.Timestamp,
 		"data":      msg.Data,
 	})
@@ -179,7 +179,7 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
 }
 
 func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) {
-	logger.InfoCF("maixcam", "Status update from MaixCam", map[string]interface{}{
+	logger.InfoCF("maixcam", "Status update from MaixCam", map[string]any{
 		"status": msg.Data,
 	})
 }
@@ -217,7 +217,7 @@ func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 		return fmt.Errorf("no connected MaixCam devices")
 	}
 
-	response := map[string]interface{}{
+	response := map[string]any{
 		"type":      "command",
 		"timestamp": float64(0),
 		"message":   msg.Content,
@@ -232,7 +232,7 @@ func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 	var sendErr error
 	for conn := range c.clients {
 		if _, err := conn.Write(data); err != nil {
-			logger.ErrorCF("maixcam", "Failed to send to client", map[string]interface{}{
+			logger.ErrorCF("maixcam", "Failed to send to client", map[string]any{
 				"client": conn.RemoteAddr().String(),
 				"error":  err.Error(),
 			})
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 091982282..7baef058c 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -47,23 +47,23 @@ func NewManager(cfg *config.Config, messageBus *bus.MessageBus) (*Manager, error
 func (m *Manager) initChannel(name, displayName string) {
 	f, ok := getFactory(name)
 	if !ok {
-		logger.WarnCF("channels", "Factory not registered", map[string]interface{}{
+		logger.WarnCF("channels", "Factory not registered", map[string]any{
 			"channel": displayName,
 		})
 		return
 	}
-	logger.DebugCF("channels", "Attempting to initialize channel", map[string]interface{}{
+	logger.DebugCF("channels", "Attempting to initialize channel", map[string]any{
 		"channel": displayName,
 	})
 	ch, err := f(m.config, m.bus)
 	if err != nil {
-		logger.ErrorCF("channels", "Failed to initialize channel", map[string]interface{}{
+		logger.ErrorCF("channels", "Failed to initialize channel", map[string]any{
 			"channel": displayName,
 			"error":   err.Error(),
 		})
 	} else {
 		m.channels[name] = ch
-		logger.InfoCF("channels", "Channel enabled successfully", map[string]interface{}{
+		logger.InfoCF("channels", "Channel enabled successfully", map[string]any{
 			"channel": displayName,
 		})
 	}
@@ -120,7 +120,7 @@ func (m *Manager) initChannels() error {
 		m.initChannel("wecom_app", "WeCom App")
 	}
 
-	logger.InfoCF("channels", "Channel initialization completed", map[string]interface{}{
+	logger.InfoCF("channels", "Channel initialization completed", map[string]any{
 		"enabled_channels": len(m.channels),
 	})
 
@@ -144,11 +144,11 @@ func (m *Manager) StartAll(ctx context.Context) error {
 	go m.dispatchOutbound(dispatchCtx)
 
 	for name, channel := range m.channels {
-		logger.InfoCF("channels", "Starting channel", map[string]interface{}{
+		logger.InfoCF("channels", "Starting channel", map[string]any{
 			"channel": name,
 		})
 		if err := channel.Start(ctx); err != nil {
-			logger.ErrorCF("channels", "Failed to start channel", map[string]interface{}{
+			logger.ErrorCF("channels", "Failed to start channel", map[string]any{
 				"channel": name,
 				"error":   err.Error(),
 			})
@@ -171,11 +171,11 @@ func (m *Manager) StopAll(ctx context.Context) error {
 	}
 
 	for name, channel := range m.channels {
-		logger.InfoCF("channels", "Stopping channel", map[string]interface{}{
+		logger.InfoCF("channels", "Stopping channel", map[string]any{
 			"channel": name,
 		})
 		if err := channel.Stop(ctx); err != nil {
-			logger.ErrorCF("channels", "Error stopping channel", map[string]interface{}{
+			logger.ErrorCF("channels", "Error stopping channel", map[string]any{
 				"channel": name,
 				"error":   err.Error(),
 			})
@@ -210,14 +210,14 @@ func (m *Manager) dispatchOutbound(ctx context.Context) {
 			m.mu.RUnlock()
 
 			if !exists {
-				logger.WarnCF("channels", "Unknown channel for outbound message", map[string]interface{}{
+				logger.WarnCF("channels", "Unknown channel for outbound message", map[string]any{
 					"channel": msg.Channel,
 				})
 				continue
 			}
 
 			if err := channel.Send(ctx, msg); err != nil {
-				logger.ErrorCF("channels", "Error sending message to channel", map[string]interface{}{
+				logger.ErrorCF("channels", "Error sending message to channel", map[string]any{
 					"channel": msg.Channel,
 					"error":   err.Error(),
 				})
@@ -233,13 +233,13 @@ func (m *Manager) GetChannel(name string) (Channel, bool) {
 	return channel, ok
 }
 
-func (m *Manager) GetStatus() map[string]interface{} {
+func (m *Manager) GetStatus() map[string]any {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 
-	status := make(map[string]interface{})
+	status := make(map[string]any)
 	for name, channel := range m.channels {
-		status[name] = map[string]interface{}{
+		status[name] = map[string]any{
 			"enabled": true,
 			"running": channel.IsRunning(),
 		}
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 209f2dc00..3d2e64e2a 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -88,14 +88,14 @@ type oneBotSender struct {
 }
 
 type oneBotAPIRequest struct {
-	Action string      `json:"action"`
-	Params interface{} `json:"params"`
-	Echo   string      `json:"echo,omitempty"`
+	Action string `json:"action"`
+	Params any    `json:"params"`
+	Echo   string `json:"echo,omitempty"`
 }
 
 type oneBotMessageSegment struct {
-	Type string                 `json:"type"`
-	Data map[string]interface{} `json:"data"`
+	Type string         `json:"type"`
+	Data map[string]any `json:"data"`
 }
 
 func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*OneBotChannel, error) {
@@ -118,13 +118,13 @@ func (c *OneBotChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
 
 func (c *OneBotChannel) setMsgEmojiLike(messageID string, emojiID int, set bool) {
 	go func() {
-		_, err := c.sendAPIRequest("set_msg_emoji_like", map[string]interface{}{
+		_, err := c.sendAPIRequest("set_msg_emoji_like", map[string]any{
 			"message_id": messageID,
 			"emoji_id":   emojiID,
 			"set":        set,
 		}, 5*time.Second)
 		if err != nil {
-			logger.DebugCF("onebot", "Failed to set emoji like", map[string]interface{}{
+			logger.DebugCF("onebot", "Failed to set emoji like", map[string]any{
 				"message_id": messageID,
 				"error":      err.Error(),
 			})
@@ -137,14 +137,14 @@ func (c *OneBotChannel) Start(ctx context.Context) error {
 		return fmt.Errorf("OneBot ws_url not configured")
 	}
 
-	logger.InfoCF("onebot", "Starting OneBot channel", map[string]interface{}{
+	logger.InfoCF("onebot", "Starting OneBot channel", map[string]any{
 		"ws_url": c.config.WSUrl,
 	})
 
 	c.ctx, c.cancel = context.WithCancel(ctx)
 
 	if err := c.connect(); err != nil {
-		logger.WarnCF("onebot", "Initial connection failed, will retry in background", map[string]interface{}{
+		logger.WarnCF("onebot", "Initial connection failed, will retry in background", map[string]any{
 			"error": err.Error(),
 		})
 	} else {
@@ -209,7 +209,7 @@ func (c *OneBotChannel) pinger(conn *websocket.Conn) {
 			err := conn.WriteMessage(websocket.PingMessage, nil)
 			c.writeMu.Unlock()
 			if err != nil {
-				logger.DebugCF("onebot", "Ping write failed, stopping pinger", map[string]interface{}{
+				logger.DebugCF("onebot", "Ping write failed, stopping pinger", map[string]any{
 					"error": err.Error(),
 				})
 				return
@@ -221,7 +221,7 @@ func (c *OneBotChannel) pinger(conn *websocket.Conn) {
 func (c *OneBotChannel) fetchSelfID() {
 	resp, err := c.sendAPIRequest("get_login_info", nil, 5*time.Second)
 	if err != nil {
-		logger.WarnCF("onebot", "Failed to get_login_info", map[string]interface{}{
+		logger.WarnCF("onebot", "Failed to get_login_info", map[string]any{
 			"error": err.Error(),
 		})
 		return
@@ -251,7 +251,7 @@ func (c *OneBotChannel) fetchSelfID() {
 		}
 		if uid, err := parseJSONInt64(info.UserID); err == nil && uid > 0 {
 			atomic.StoreInt64(&c.selfID, uid)
-			logger.InfoCF("onebot", "Bot self ID retrieved", map[string]interface{}{
+			logger.InfoCF("onebot", "Bot self ID retrieved", map[string]any{
 				"self_id":  uid,
 				"nickname": info.Nickname,
 			})
@@ -259,12 +259,12 @@ func (c *OneBotChannel) fetchSelfID() {
 		}
 	}
 
-	logger.WarnCF("onebot", "Could not parse self ID from get_login_info response", map[string]interface{}{
+	logger.WarnCF("onebot", "Could not parse self ID from get_login_info response", map[string]any{
 		"response": string(resp),
 	})
 }
 
-func (c *OneBotChannel) sendAPIRequest(action string, params interface{}, timeout time.Duration) (json.RawMessage, error) {
+func (c *OneBotChannel) sendAPIRequest(action string, params any, timeout time.Duration) (json.RawMessage, error) {
 	c.mu.Lock()
 	conn := c.conn
 	c.mu.Unlock()
@@ -333,7 +333,7 @@ func (c *OneBotChannel) reconnectLoop() {
 			if conn == nil {
 				logger.InfoC("onebot", "Attempting to reconnect...")
 				if err := c.connect(); err != nil {
-					logger.ErrorCF("onebot", "Reconnect failed", map[string]interface{}{
+					logger.ErrorCF("onebot", "Reconnect failed", map[string]any{
 						"error": err.Error(),
 					})
 				} else {
@@ -406,7 +406,7 @@ func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 	c.writeMu.Unlock()
 
 	if err != nil {
-		logger.ErrorCF("onebot", "Failed to send message", map[string]interface{}{
+		logger.ErrorCF("onebot", "Failed to send message", map[string]any{
 			"error": err.Error(),
 		})
 		return err
@@ -428,20 +428,20 @@ func (c *OneBotChannel) buildMessageSegments(chatID, content string) []oneBotMes
 		if msgID, ok := lastMsgID.(string); ok && msgID != "" {
 			segments = append(segments, oneBotMessageSegment{
 				Type: "reply",
-				Data: map[string]interface{}{"id": msgID},
+				Data: map[string]any{"id": msgID},
 			})
 		}
 	}
 
 	segments = append(segments, oneBotMessageSegment{
 		Type: "text",
-		Data: map[string]interface{}{"text": content},
+		Data: map[string]any{"text": content},
 	})
 
 	return segments
 }
 
-func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, interface{}, error) {
+func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, any, error) {
 	chatID := msg.ChatID
 	segments := c.buildMessageSegments(chatID, msg.Content)
 
@@ -459,7 +459,7 @@ func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, inter
 	if err != nil {
 		return "", nil, fmt.Errorf("invalid %s in chatID: %s", idKey, chatID)
 	}
-	return action, map[string]interface{}{idKey: id, "message": segments}, nil
+	return action, map[string]any{idKey: id, "message": segments}, nil
 }
 
 func (c *OneBotChannel) listen() {
@@ -479,7 +479,7 @@ func (c *OneBotChannel) listen() {
 		default:
 			_, message, err := conn.ReadMessage()
 			if err != nil {
-				logger.ErrorCF("onebot", "WebSocket read error", map[string]interface{}{
+				logger.ErrorCF("onebot", "WebSocket read error", map[string]any{
 					"error": err.Error(),
 				})
 				c.mu.Lock()
@@ -495,14 +495,14 @@ func (c *OneBotChannel) listen() {
 
 			var raw oneBotRawEvent
 			if err := json.Unmarshal(message, &raw); err != nil {
-				logger.WarnCF("onebot", "Failed to unmarshal raw event", map[string]interface{}{
+				logger.WarnCF("onebot", "Failed to unmarshal raw event", map[string]any{
 					"error":   err.Error(),
 					"payload": string(message),
 				})
 				continue
 			}
 
-			logger.DebugCF("onebot", "WebSocket event", map[string]interface{}{
+			logger.DebugCF("onebot", "WebSocket event", map[string]any{
 				"length":    len(message),
 				"post_type": raw.PostType,
 				"sub_type":  raw.SubType,
@@ -519,7 +519,7 @@ func (c *OneBotChannel) listen() {
 					default:
 					}
 				} else {
-					logger.DebugCF("onebot", "Received API response (no waiter)", map[string]interface{}{
+					logger.DebugCF("onebot", "Received API response (no waiter)", map[string]any{
 						"echo":   raw.Echo,
 						"status": string(raw.Status),
 					})
@@ -528,7 +528,7 @@ func (c *OneBotChannel) listen() {
 			}
 
 			if isAPIResponse(raw.Status) {
-				logger.DebugCF("onebot", "Received API response without echo, skipping", map[string]interface{}{
+				logger.DebugCF("onebot", "Received API response without echo, skipping", map[string]any{
 					"status": string(raw.Status),
 				})
 				continue
@@ -595,7 +595,7 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 		return parseMessageResult{Text: s, IsBotMentioned: mentioned}
 	}
 
-	var segments []map[string]interface{}
+	var segments []map[string]any
 	if err := json.Unmarshal(raw, &segments); err != nil {
 		return parseMessageResult{}
 	}
@@ -609,7 +609,7 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 
 	for _, seg := range segments {
 		segType, _ := seg["type"].(string)
-		data, _ := seg["data"].(map[string]interface{})
+		data, _ := seg["data"].(map[string]any)
 
 		switch segType {
 		case "text":
@@ -663,7 +663,7 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 							result, err := c.transcriber.Transcribe(tctx, localPath)
 							tcancel()
 							if err != nil {
-								logger.WarnCF("onebot", "Voice transcription failed", map[string]interface{}{
+								logger.WarnCF("onebot", "Voice transcription failed", map[string]any{
 									"error": err.Error(),
 								})
 								textParts = append(textParts, "[voice (transcription failed)]")
@@ -714,7 +714,7 @@ func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
 	case "message":
 		if userID, err := parseJSONInt64(raw.UserID); err == nil && userID > 0 {
 			if !c.IsAllowed(strconv.FormatInt(userID, 10)) {
-				logger.DebugCF("onebot", "Message rejected by allowlist", map[string]interface{}{
+				logger.DebugCF("onebot", "Message rejected by allowlist", map[string]any{
 					"user_id": userID,
 				})
 				return
@@ -723,7 +723,7 @@ func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
 		c.handleMessage(raw)
 
 	case "message_sent":
-		logger.DebugCF("onebot", "Bot sent message event", map[string]interface{}{
+		logger.DebugCF("onebot", "Bot sent message event", map[string]any{
 			"message_type": raw.MessageType,
 			"message_id":   parseJSONString(raw.MessageID),
 		})
@@ -735,18 +735,18 @@ func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
 		c.handleNoticeEvent(raw)
 
 	case "request":
-		logger.DebugCF("onebot", "Request event received", map[string]interface{}{
+		logger.DebugCF("onebot", "Request event received", map[string]any{
 			"sub_type": raw.SubType,
 		})
 
 	case "":
-		logger.DebugCF("onebot", "Event with empty post_type (possibly API response)", map[string]interface{}{
+		logger.DebugCF("onebot", "Event with empty post_type (possibly API response)", map[string]any{
 			"echo":   raw.Echo,
 			"status": raw.Status,
 		})
 
 	default:
-		logger.DebugCF("onebot", "Unknown post_type", map[string]interface{}{
+		logger.DebugCF("onebot", "Unknown post_type", map[string]any{
 			"post_type": raw.PostType,
 		})
 	}
@@ -754,14 +754,14 @@ func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
 
 func (c *OneBotChannel) handleMetaEvent(raw *oneBotRawEvent) {
 	if raw.MetaEventType == "lifecycle" {
-		logger.InfoCF("onebot", "Lifecycle event", map[string]interface{}{"sub_type": raw.SubType})
+		logger.InfoCF("onebot", "Lifecycle event", map[string]any{"sub_type": raw.SubType})
 	} else if raw.MetaEventType != "heartbeat" {
 		logger.DebugCF("onebot", "Meta event: "+raw.MetaEventType, nil)
 	}
 }
 
 func (c *OneBotChannel) handleNoticeEvent(raw *oneBotRawEvent) {
-	fields := map[string]interface{}{
+	fields := map[string]any{
 		"notice_type": raw.NoticeType,
 		"sub_type":    raw.SubType,
 		"group_id":    parseJSONString(raw.GroupID),
@@ -781,7 +781,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	// Parse fields from raw event
 	userID, err := parseJSONInt64(raw.UserID)
 	if err != nil {
-		logger.WarnCF("onebot", "Failed to parse user_id", map[string]interface{}{
+		logger.WarnCF("onebot", "Failed to parse user_id", map[string]any{
 			"error": err.Error(),
 			"raw":   string(raw.UserID),
 		})
@@ -818,7 +818,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	var sender oneBotSender
 	if len(raw.Sender) > 0 {
 		if err := json.Unmarshal(raw.Sender, &sender); err != nil {
-			logger.WarnCF("onebot", "Failed to parse sender", map[string]interface{}{
+			logger.WarnCF("onebot", "Failed to parse sender", map[string]any{
 				"error":  err.Error(),
 				"sender": string(raw.Sender),
 			})
@@ -830,7 +830,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		defer func() {
 			for _, f := range parsed.LocalFiles {
 				if err := os.Remove(f); err != nil {
-					logger.DebugCF("onebot", "Failed to remove temp file", map[string]interface{}{
+					logger.DebugCF("onebot", "Failed to remove temp file", map[string]any{
 						"path":  f,
 						"error": err.Error(),
 					})
@@ -840,14 +840,14 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	}
 
 	if c.isDuplicate(messageID) {
-		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]interface{}{
+		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]any{
 			"message_id": messageID,
 		})
 		return
 	}
 
 	if content == "" {
-		logger.DebugCF("onebot", "Received empty message, ignoring", map[string]interface{}{
+		logger.DebugCF("onebot", "Received empty message, ignoring", map[string]any{
 			"message_id": messageID,
 		})
 		return
@@ -890,7 +890,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 
 		triggered, strippedContent := c.checkGroupTrigger(content, isBotMentioned)
 		if !triggered {
-			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]interface{}{
+			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]any{
 				"sender":       senderID,
 				"group":        groupIDStr,
 				"is_mentioned": isBotMentioned,
@@ -901,7 +901,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		content = strippedContent
 
 	default:
-		logger.WarnCF("onebot", "Unknown message type, cannot route", map[string]interface{}{
+		logger.WarnCF("onebot", "Unknown message type, cannot route", map[string]any{
 			"type":       raw.MessageType,
 			"message_id": messageID,
 			"user_id":    userID,
@@ -909,7 +909,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		return
 	}
 
-	logger.InfoCF("onebot", "Received "+raw.MessageType+" message", map[string]interface{}{
+	logger.InfoCF("onebot", "Received "+raw.MessageType+" message", map[string]any{
 		"sender":      senderID,
 		"chat_id":     chatID,
 		"message_id":  messageID,
@@ -962,7 +962,10 @@ func truncate(s string, n int) string {
 	return string(runes[:n]) + "..."
 }
 
-func (c *OneBotChannel) checkGroupTrigger(content string, isBotMentioned bool) (triggered bool, strippedContent string) {
+func (c *OneBotChannel) checkGroupTrigger(
+	content string,
+	isBotMentioned bool,
+) (triggered bool, strippedContent string) {
 	if isBotMentioned {
 		return true, strings.TrimSpace(content)
 	}
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 9b07be0cc..2a95bbd06 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -78,7 +78,7 @@ func (c *QQChannel) Start(ctx context.Context) error {
 		return fmt.Errorf("failed to get websocket info: %w", err)
 	}
 
-	logger.InfoCF("qq", "Got WebSocket info", map[string]interface{}{
+	logger.InfoCF("qq", "Got WebSocket info", map[string]any{
 		"shards": wsInfo.Shards,
 	})
 
@@ -88,7 +88,7 @@ func (c *QQChannel) Start(ctx context.Context) error {
 	// 在 goroutine 中启动 WebSocket 连接，避免阻塞
 	go func() {
 		if err := c.sessionManager.Start(wsInfo, c.tokenSource, &intent); err != nil {
-			logger.ErrorCF("qq", "WebSocket session error", map[string]interface{}{
+			logger.ErrorCF("qq", "WebSocket session error", map[string]any{
 				"error": err.Error(),
 			})
 			c.SetRunning(false)
@@ -125,7 +125,7 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	// C2C 消息发送
 	_, err := c.api.PostC2CMessage(ctx, msg.ChatID, msgToCreate)
 	if err != nil {
-		logger.ErrorCF("qq", "Failed to send C2C message", map[string]interface{}{
+		logger.ErrorCF("qq", "Failed to send C2C message", map[string]any{
 			"error": err.Error(),
 		})
 		return err
@@ -158,7 +158,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 			return nil
 		}
 
-		logger.InfoCF("qq", "Received C2C message", map[string]interface{}{
+		logger.InfoCF("qq", "Received C2C message", map[string]any{
 			"sender": senderID,
 			"length": len(content),
 		})
@@ -200,7 +200,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			return nil
 		}
 
-		logger.InfoCF("qq", "Received group AT message", map[string]interface{}{
+		logger.InfoCF("qq", "Received group AT message", map[string]any{
 			"sender": senderID,
 			"group":  data.GroupID,
 			"length": len(content),
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index dc5190fc9..cafe53103 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -76,7 +76,7 @@ func (c *SlackChannel) Start(ctx context.Context) error {
 	c.botUserID = authResp.UserID
 	c.teamID = authResp.TeamID
 
-	logger.InfoCF("slack", "Slack bot connected", map[string]interface{}{
+	logger.InfoCF("slack", "Slack bot connected", map[string]any{
 		"bot_user_id": c.botUserID,
 		"team":        authResp.Team,
 	})
@@ -86,7 +86,7 @@ func (c *SlackChannel) Start(ctx context.Context) error {
 	go func() {
 		if err := c.socketClient.RunContext(c.ctx); err != nil {
 			if c.ctx.Err() == nil {
-				logger.ErrorCF("slack", "Socket Mode connection error", map[string]interface{}{
+				logger.ErrorCF("slack", "Socket Mode connection error", map[string]any{
 					"error": err.Error(),
 				})
 			}
@@ -141,7 +141,7 @@ func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 		})
 	}
 
-	logger.DebugCF("slack", "Message sent", map[string]interface{}{
+	logger.DebugCF("slack", "Message sent", map[string]any{
 		"channel_id": channelID,
 		"thread_ts":  threadTS,
 	})
@@ -203,7 +203,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 
 	// 检查白名单，避免为被拒绝的用户下载附件
 	if !c.IsAllowed(ev.User) {
-		logger.DebugCF("slack", "Message rejected by allowlist", map[string]interface{}{
+		logger.DebugCF("slack", "Message rejected by allowlist", map[string]any{
 			"user_id": ev.User,
 		})
 		return
@@ -239,7 +239,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 	defer func() {
 		for _, file := range localFiles {
 			if err := os.Remove(file); err != nil {
-				logger.DebugCF("slack", "Failed to cleanup temp file", map[string]interface{}{
+				logger.DebugCF("slack", "Failed to cleanup temp file", map[string]any{
 					"file":  file,
 					"error": err.Error(),
 				})
@@ -262,7 +262,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 				result, err := c.transcriber.Transcribe(ctx, localPath)
 
 				if err != nil {
-					logger.ErrorCF("slack", "Voice transcription failed", map[string]interface{}{"error": err.Error()})
+					logger.ErrorCF("slack", "Voice transcription failed", map[string]any{"error": err.Error()})
 					content += fmt.Sprintf("\n[audio: %s (transcription failed)]", file.Name)
 				} else {
 					content += fmt.Sprintf("\n[voice transcription: %s]", result.Text)
@@ -294,7 +294,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		"team_id":    c.teamID,
 	}
 
-	logger.DebugCF("slack", "Received message", map[string]interface{}{
+	logger.DebugCF("slack", "Received message", map[string]any{
 		"sender_id":  senderID,
 		"chat_id":    chatID,
 		"preview":    utils.Truncate(content, 50),
@@ -310,7 +310,7 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 	}
 
 	if !c.IsAllowed(ev.User) {
-		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]interface{}{
+		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]any{
 			"user_id": ev.User,
 		})
 		return
@@ -376,7 +376,7 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 	}
 
 	if !c.IsAllowed(cmd.UserID) {
-		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]interface{}{
+		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]any{
 			"user_id": cmd.UserID,
 		})
 		return
@@ -401,7 +401,7 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		"team_id":    c.teamID,
 	}
 
-	logger.DebugCF("slack", "Slash command received", map[string]interface{}{
+	logger.DebugCF("slack", "Slash command received", map[string]any{
 		"sender_id": senderID,
 		"command":   cmd.Command,
 		"text":      utils.Truncate(content, 50),
@@ -416,7 +416,7 @@ func (c *SlackChannel) downloadSlackFile(file slack.File) string {
 		downloadURL = file.URLPrivate
 	}
 	if downloadURL == "" {
-		logger.ErrorCF("slack", "No download URL for file", map[string]interface{}{"file_id": file.ID})
+		logger.ErrorCF("slack", "No download URL for file", map[string]any{"file_id": file.ID})
 		return ""
 	}
 
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index f4c5108df..7619440e2 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -11,10 +11,9 @@ import (
 	"sync"
 	"time"
 
-	th "github.com/mymmrac/telego/telegohandler"
-
 	"github.com/mymmrac/telego"
 	"github.com/mymmrac/telego/telegohandler"
+	th "github.com/mymmrac/telego/telegohandler"
 	tu "github.com/mymmrac/telego/telegoutil"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
@@ -128,7 +127,7 @@ func (c *TelegramChannel) Start(ctx context.Context) error {
 	}, th.AnyMessage())
 
 	c.SetRunning(true)
-	logger.InfoCF("telegram", "Telegram bot connected", map[string]interface{}{
+	logger.InfoCF("telegram", "Telegram bot connected", map[string]any{
 		"username": c.bot.Username(),
 	})
 
@@ -141,6 +140,7 @@ func (c *TelegramChannel) Start(ctx context.Context) error {
 
 	return nil
 }
+
 func (c *TelegramChannel) Stop(ctx context.Context) error {
 	logger.InfoC("telegram", "Stopping Telegram bot...")
 	c.SetRunning(false)
@@ -183,7 +183,7 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	tgMsg.ParseMode = telego.ModeHTML
 
 	if _, err = c.bot.SendMessage(ctx, tgMsg); err != nil {
-		logger.ErrorCF("telegram", "HTML parse failed, falling back to plain text", map[string]interface{}{
+		logger.ErrorCF("telegram", "HTML parse failed, falling back to plain text", map[string]any{
 			"error": err.Error(),
 		})
 		tgMsg.ParseMode = ""
@@ -211,7 +211,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 
 	// 检查白名单，避免为被拒绝的用户下载附件
 	if !c.IsAllowed(senderID) {
-		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]interface{}{
+		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]any{
 			"user_id": senderID,
 		})
 		return nil
@@ -228,7 +228,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	defer func() {
 		for _, file := range localFiles {
 			if err := os.Remove(file); err != nil {
-				logger.DebugCF("telegram", "Failed to cleanup temp file", map[string]interface{}{
+				logger.DebugCF("telegram", "Failed to cleanup temp file", map[string]any{
 					"file":  file,
 					"error": err.Error(),
 				})
@@ -268,19 +268,19 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 
 			transcribedText := ""
 			if c.transcriber != nil && c.transcriber.IsAvailable() {
-				ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+				transcriberCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
 				defer cancel()
 
-				result, err := c.transcriber.Transcribe(ctx, voicePath)
+				result, err := c.transcriber.Transcribe(transcriberCtx, voicePath)
 				if err != nil {
-					logger.ErrorCF("telegram", "Voice transcription failed", map[string]interface{}{
+					logger.ErrorCF("telegram", "Voice transcription failed", map[string]any{
 						"error": err.Error(),
 						"path":  voicePath,
 					})
 					transcribedText = "[voice (transcription failed)]"
 				} else {
 					transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
-					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]interface{}{
+					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]any{
 						"text": result.Text,
 					})
 				}
@@ -323,7 +323,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		content = "[empty message]"
 	}
 
-	logger.DebugCF("telegram", "Received message", map[string]interface{}{
+	logger.DebugCF("telegram", "Received message", map[string]any{
 		"sender_id": senderID,
 		"chat_id":   fmt.Sprintf("%d", chatID),
 		"preview":   utils.Truncate(content, 50),
@@ -332,7 +332,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	// Thinking indicator
 	err := c.bot.SendChatAction(ctx, tu.ChatAction(tu.ID(chatID), telego.ChatActionTyping))
 	if err != nil {
-		logger.ErrorCF("telegram", "Failed to send chat action", map[string]interface{}{
+		logger.ErrorCF("telegram", "Failed to send chat action", map[string]any{
 			"error": err.Error(),
 		})
 	}
@@ -379,7 +379,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 func (c *TelegramChannel) downloadPhoto(ctx context.Context, fileID string) string {
 	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
 	if err != nil {
-		logger.ErrorCF("telegram", "Failed to get photo file", map[string]interface{}{
+		logger.ErrorCF("telegram", "Failed to get photo file", map[string]any{
 			"error": err.Error(),
 		})
 		return ""
@@ -394,7 +394,7 @@ func (c *TelegramChannel) downloadFileWithInfo(file *telego.File, ext string) st
 	}
 
 	url := c.bot.FileDownloadURL(file.FilePath)
-	logger.DebugCF("telegram", "File URL", map[string]interface{}{"url": url})
+	logger.DebugCF("telegram", "File URL", map[string]any{"url": url})
 
 	// Use FilePath as filename for better identification
 	filename := file.FilePath + ext
@@ -406,7 +406,7 @@ func (c *TelegramChannel) downloadFileWithInfo(file *telego.File, ext string) st
 func (c *TelegramChannel) downloadFile(ctx context.Context, fileID, ext string) string {
 	file, err := c.bot.GetFile(ctx, &telego.GetFileParams{FileID: fileID})
 	if err != nil {
-		logger.ErrorCF("telegram", "Failed to get file", map[string]interface{}{
+		logger.ErrorCF("telegram", "Failed to get file", map[string]any{
 			"error": err.Error(),
 		})
 		return ""
@@ -464,7 +464,11 @@ func markdownToTelegramHTML(text string) string {
 
 	for i, code := range codeBlocks.codes {
 		escaped := escapeHTML(code)
-		text = strings.ReplaceAll(text, fmt.Sprintf("\x00CB%d\x00", i), fmt.Sprintf("<pre><code>%s</code></pre>", escaped))
+		text = strings.ReplaceAll(
+			text,
+			fmt.Sprintf("\x00CB%d\x00", i),
+			fmt.Sprintf("<pre><code>%s</code></pre>", escaped),
+		)
 	}
 
 	return text
diff --git a/pkg/channels/telegram/telegram_commands.go b/pkg/channels/telegram/telegram_commands.go
index 4bf1b3aff..f17912260 100644
--- a/pkg/channels/telegram/telegram_commands.go
+++ b/pkg/channels/telegram/telegram_commands.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/mymmrac/telego"
+
 	"github.com/sipeed/picoclaw/pkg/config"
 )
 
@@ -35,6 +36,7 @@ func commandArgs(text string) string {
 	}
 	return strings.TrimSpace(parts[1])
 }
+
 func (c *cmd) Help(ctx context.Context, message telego.Message) error {
 	msg := `/start - Start the bot
 /help - Show this help message
@@ -96,6 +98,7 @@ func (c *cmd) Show(ctx context.Context, message telego.Message) error {
 	})
 	return err
 }
+
 func (c *cmd) List(ctx context.Context, message telego.Message) error {
 	args := commandArgs(message.Text)
 	if args == "" {
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 85c017958..f3557d60f 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -142,7 +142,7 @@ func (c *WeComAppChannel) Start(ctx context.Context) error {
 
 	// Get initial access token
 	if err := c.refreshAccessToken(); err != nil {
-		logger.WarnCF("wecom_app", "Failed to get initial access token", map[string]interface{}{
+		logger.WarnCF("wecom_app", "Failed to get initial access token", map[string]any{
 			"error": err.Error(),
 		})
 	}
@@ -168,7 +168,7 @@ func (c *WeComAppChannel) Start(ctx context.Context) error {
 	}
 
 	c.SetRunning(true)
-	logger.InfoCF("wecom_app", "WeCom App channel started", map[string]interface{}{
+	logger.InfoCF("wecom_app", "WeCom App channel started", map[string]any{
 		"address": addr,
 		"path":    webhookPath,
 	})
@@ -176,7 +176,7 @@ func (c *WeComAppChannel) Start(ctx context.Context) error {
 	// Start server in goroutine
 	go func() {
 		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom_app", "HTTP server error", map[string]interface{}{
+			logger.ErrorCF("wecom_app", "HTTP server error", map[string]any{
 				"error": err.Error(),
 			})
 		}
@@ -215,7 +215,7 @@ func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("no valid access token available")
 	}
 
-	logger.DebugCF("wecom_app", "Sending message", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Sending message", map[string]any{
 		"chat_id": msg.ChatID,
 		"preview": utils.Truncate(msg.Content, 100),
 	})
@@ -228,7 +228,7 @@ func (c *WeComAppChannel) handleWebhook(w http.ResponseWriter, r *http.Request)
 	ctx := r.Context()
 
 	// Log all incoming requests for debugging
-	logger.DebugCF("wecom_app", "Received webhook request", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Received webhook request", map[string]any{
 		"method": r.Method,
 		"url":    r.URL.String(),
 		"path":   r.URL.Path,
@@ -247,7 +247,7 @@ func (c *WeComAppChannel) handleWebhook(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	logger.WarnCF("wecom_app", "Method not allowed", map[string]interface{}{
+	logger.WarnCF("wecom_app", "Method not allowed", map[string]any{
 		"method": r.Method,
 	})
 	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -261,7 +261,7 @@ func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.Respons
 	nonce := query.Get("nonce")
 	echostr := query.Get("echostr")
 
-	logger.DebugCF("wecom_app", "Handling verification request", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Handling verification request", map[string]any{
 		"msg_signature": msgSignature,
 		"timestamp":     timestamp,
 		"nonce":         nonce,
@@ -277,7 +277,7 @@ func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.Respons
 
 	// Verify signature
 	if !verifySignature(c.config.Token, msgSignature, timestamp, nonce, echostr) {
-		logger.WarnCF("wecom_app", "Signature verification failed", map[string]interface{}{
+		logger.WarnCF("wecom_app", "Signature verification failed", map[string]any{
 			"token":         c.config.Token,
 			"msg_signature": msgSignature,
 			"timestamp":     timestamp,
@@ -291,13 +291,13 @@ func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.Respons
 
 	// Decrypt echostr with CorpID verification
 	// For WeCom App (自建应用), receiveid should be corp_id
-	logger.DebugCF("wecom_app", "Attempting to decrypt echostr", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Attempting to decrypt echostr", map[string]any{
 		"encoding_aes_key": c.config.EncodingAESKey,
 		"corp_id":          c.config.CorpID,
 	})
 	decryptedEchoStr, err := decryptMessageWithVerify(echostr, c.config.EncodingAESKey, c.config.CorpID)
 	if err != nil {
-		logger.ErrorCF("wecom_app", "Failed to decrypt echostr", map[string]interface{}{
+		logger.ErrorCF("wecom_app", "Failed to decrypt echostr", map[string]any{
 			"error":            err.Error(),
 			"encoding_aes_key": c.config.EncodingAESKey,
 			"corp_id":          c.config.CorpID,
@@ -306,7 +306,7 @@ func (c *WeComAppChannel) handleVerification(ctx context.Context, w http.Respons
 		return
 	}
 
-	logger.DebugCF("wecom_app", "Successfully decrypted echostr", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Successfully decrypted echostr", map[string]any{
 		"decrypted": decryptedEchoStr,
 	})
 
@@ -345,8 +345,8 @@ func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.Resp
 		AgentID    string   `xml:"AgentID"`
 	}
 
-	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
-		logger.ErrorCF("wecom_app", "Failed to parse XML", map[string]interface{}{
+	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
+		logger.ErrorCF("wecom_app", "Failed to parse XML", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Invalid XML", http.StatusBadRequest)
@@ -364,7 +364,7 @@ func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.Resp
 	// For WeCom App (自建应用), receiveid should be corp_id
 	decryptedMsg, err := decryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, c.config.CorpID)
 	if err != nil {
-		logger.ErrorCF("wecom_app", "Failed to decrypt message", map[string]interface{}{
+		logger.ErrorCF("wecom_app", "Failed to decrypt message", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Decryption failed", http.StatusInternalServerError)
@@ -374,7 +374,7 @@ func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.Resp
 	// Parse decrypted XML message
 	var msg WeComXMLMessage
 	if err := xml.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
-		logger.ErrorCF("wecom_app", "Failed to parse decrypted message", map[string]interface{}{
+		logger.ErrorCF("wecom_app", "Failed to parse decrypted message", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Invalid message format", http.StatusBadRequest)
@@ -393,7 +393,7 @@ func (c *WeComAppChannel) handleMessageCallback(ctx context.Context, w http.Resp
 func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessage) {
 	// Skip non-text messages for now (can be extended)
 	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" {
-		logger.DebugCF("wecom_app", "Skipping non-supported message type", map[string]interface{}{
+		logger.DebugCF("wecom_app", "Skipping non-supported message type", map[string]any{
 			"msg_type": msg.MsgType,
 		})
 		return
@@ -405,7 +405,7 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 	c.msgMu.Lock()
 	if c.processedMsgs[msgID] {
 		c.msgMu.Unlock()
-		logger.DebugCF("wecom_app", "Skipping duplicate message", map[string]interface{}{
+		logger.DebugCF("wecom_app", "Skipping duplicate message", map[string]any{
 			"msg_id": msgID,
 		})
 		return
@@ -438,7 +438,7 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 
 	content := msg.Content
 
-	logger.DebugCF("wecom_app", "Received message", map[string]interface{}{
+	logger.DebugCF("wecom_app", "Received message", map[string]any{
 		"sender_id": senderID,
 		"msg_type":  msg.MsgType,
 		"preview":   utils.Truncate(content, 50),
@@ -459,7 +459,7 @@ func (c *WeComAppChannel) tokenRefreshLoop() {
 			return
 		case <-ticker.C:
 			if err := c.refreshAccessToken(); err != nil {
-				logger.ErrorCF("wecom_app", "Failed to refresh access token", map[string]interface{}{
+				logger.ErrorCF("wecom_app", "Failed to refresh access token", map[string]any{
 					"error": err.Error(),
 				})
 			}
@@ -625,7 +625,7 @@ func (c *WeComAppChannel) sendMarkdownMessage(ctx context.Context, accessToken,
 
 // handleHealth handles health check requests
 func (c *WeComAppChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
-	status := map[string]interface{}{
+	status := map[string]any{
 		"status":    "ok",
 		"running":   c.IsRunning(),
 		"has_token": c.getAccessToken() != "",
diff --git a/pkg/channels/wecom/app_test.go b/pkg/channels/wecom/app_test.go
index d9817fd49..5420949de 100644
--- a/pkg/channels/wecom/app_test.go
+++ b/pkg/channels/wecom/app_test.go
@@ -396,7 +396,11 @@ func TestWeComAppHandleVerification(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedEchostr)
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleVerification(context.Background(), w, req)
@@ -426,7 +430,11 @@ func TestWeComAppHandleVerification(t *testing.T) {
 		timestamp := "1234567890"
 		nonce := "test_nonce"
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleVerification(context.Background(), w, req)
@@ -478,7 +486,11 @@ func TestWeComAppHandleMessageCallback(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignatureApp("test_token", timestamp, nonce, encrypted)
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -507,7 +519,11 @@ func TestWeComAppHandleMessageCallback(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignatureApp("test_token", timestamp, nonce, "")
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, strings.NewReader("invalid xml"))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			strings.NewReader("invalid xml"),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -529,7 +545,11 @@ func TestWeComAppHandleMessageCallback(t *testing.T) {
 		timestamp := "1234567890"
 		nonce := "test_nonce"
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom-app?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -643,7 +663,11 @@ func TestWeComAppHandleWebhook(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignatureApp("test_token", timestamp, nonce, encoded)
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleWebhook(w, req)
@@ -666,7 +690,11 @@ func TestWeComAppHandleWebhook(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignatureApp("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom-app?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleWebhook(w, req)
@@ -832,15 +860,24 @@ func TestWeComAppMessageStructures(t *testing.T) {
 		if msg.Image.MediaID != "media_123456" {
 			t.Errorf("Image.MediaID = %q, want %q", msg.Image.MediaID, "media_123456")
 		}
+		if msg.ToUser != "user123" {
+			t.Errorf("ToUser = %q, want %q", msg.ToUser, "user123")
+		}
+		if msg.MsgType != "image" {
+			t.Errorf("MsgType = %q, want %q", msg.MsgType, "image")
+		}
+		if msg.AgentID != 1000002 {
+			t.Errorf("AgentID = %d, want %d", msg.AgentID, 1000002)
+		}
 	})
 
 	t.Run("WeComAccessTokenResponse structure", func(t *testing.T) {
 		jsonData := `{
-				"errcode": 0,
-				"errmsg": "ok",
-				"access_token": "test_access_token",
-				"expires_in": 7200
-			}`
+			"errcode": 0,
+			"errmsg": "ok",
+			"access_token": "test_access_token",
+			"expires_in": 7200
+		}`
 
 		var resp WeComAccessTokenResponse
 		err := json.Unmarshal([]byte(jsonData), &resp)
@@ -864,12 +901,12 @@ func TestWeComAppMessageStructures(t *testing.T) {
 
 	t.Run("WeComSendMessageResponse structure", func(t *testing.T) {
 		jsonData := `{
-				"errcode": 0,
-				"errmsg": "ok",
-				"invaliduser": "",
-				"invalidparty": "",
-				"invalidtag": ""
-			}`
+			"errcode": 0,
+			"errmsg": "ok",
+			"invaliduser": "",
+			"invalidparty": "",
+			"invalidtag": ""
+		}`
 
 		var resp WeComSendMessageResponse
 		err := json.Unmarshal([]byte(jsonData), &resp)
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 9683a308f..17ee2107f 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -125,7 +125,7 @@ func (c *WeComBotChannel) Start(ctx context.Context) error {
 	}
 
 	c.SetRunning(true)
-	logger.InfoCF("wecom", "WeCom Bot channel started", map[string]interface{}{
+	logger.InfoCF("wecom", "WeCom Bot channel started", map[string]any{
 		"address": addr,
 		"path":    webhookPath,
 	})
@@ -133,7 +133,7 @@ func (c *WeComBotChannel) Start(ctx context.Context) error {
 	// Start server in goroutine
 	go func() {
 		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom", "HTTP server error", map[string]interface{}{
+			logger.ErrorCF("wecom", "HTTP server error", map[string]any{
 				"error": err.Error(),
 			})
 		}
@@ -169,7 +169,7 @@ func (c *WeComBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("wecom channel not running")
 	}
 
-	logger.DebugCF("wecom", "Sending message via webhook", map[string]interface{}{
+	logger.DebugCF("wecom", "Sending message via webhook", map[string]any{
 		"chat_id": msg.ChatID,
 		"preview": utils.Truncate(msg.Content, 100),
 	})
@@ -221,7 +221,7 @@ func (c *WeComBotChannel) handleVerification(ctx context.Context, w http.Respons
 	// Reference: https://developer.work.weixin.qq.com/document/path/101033
 	decryptedEchoStr, err := decryptMessageWithVerify(echostr, c.config.EncodingAESKey, "")
 	if err != nil {
-		logger.ErrorCF("wecom", "Failed to decrypt echostr", map[string]interface{}{
+		logger.ErrorCF("wecom", "Failed to decrypt echostr", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Decryption failed", http.StatusInternalServerError)
@@ -263,8 +263,8 @@ func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.Resp
 		AgentID    string   `xml:"AgentID"`
 	}
 
-	if err := xml.Unmarshal(body, &encryptedMsg); err != nil {
-		logger.ErrorCF("wecom", "Failed to parse XML", map[string]interface{}{
+	if err = xml.Unmarshal(body, &encryptedMsg); err != nil {
+		logger.ErrorCF("wecom", "Failed to parse XML", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Invalid XML", http.StatusBadRequest)
@@ -283,7 +283,7 @@ func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.Resp
 	// Reference: https://developer.work.weixin.qq.com/document/path/101033
 	decryptedMsg, err := decryptMessageWithVerify(encryptedMsg.Encrypt, c.config.EncodingAESKey, "")
 	if err != nil {
-		logger.ErrorCF("wecom", "Failed to decrypt message", map[string]interface{}{
+		logger.ErrorCF("wecom", "Failed to decrypt message", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Decryption failed", http.StatusInternalServerError)
@@ -293,7 +293,7 @@ func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.Resp
 	// Parse decrypted JSON message (AIBOT uses JSON format)
 	var msg WeComBotMessage
 	if err := json.Unmarshal([]byte(decryptedMsg), &msg); err != nil {
-		logger.ErrorCF("wecom", "Failed to parse decrypted message", map[string]interface{}{
+		logger.ErrorCF("wecom", "Failed to parse decrypted message", map[string]any{
 			"error": err.Error(),
 		})
 		http.Error(w, "Invalid message format", http.StatusBadRequest)
@@ -311,8 +311,9 @@ func (c *WeComBotChannel) handleMessageCallback(ctx context.Context, w http.Resp
 // processMessage processes the received message
 func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessage) {
 	// Skip unsupported message types
-	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" && msg.MsgType != "file" && msg.MsgType != "mixed" {
-		logger.DebugCF("wecom", "Skipping non-supported message type", map[string]interface{}{
+	if msg.MsgType != "text" && msg.MsgType != "image" && msg.MsgType != "voice" && msg.MsgType != "file" &&
+		msg.MsgType != "mixed" {
+		logger.DebugCF("wecom", "Skipping non-supported message type", map[string]any{
 			"msg_type": msg.MsgType,
 		})
 		return
@@ -323,7 +324,7 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 	c.msgMu.Lock()
 	if c.processedMsgs[msgID] {
 		c.msgMu.Unlock()
-		logger.DebugCF("wecom", "Skipping duplicate message", map[string]interface{}{
+		logger.DebugCF("wecom", "Skipping duplicate message", map[string]any{
 			"msg_id": msgID,
 		})
 		return
@@ -390,7 +391,7 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 		metadata["sender_id"] = senderID
 	}
 
-	logger.DebugCF("wecom", "Received message", map[string]interface{}{
+	logger.DebugCF("wecom", "Received message", map[string]any{
 		"sender_id":     senderID,
 		"msg_type":      msg.MsgType,
 		"peer_kind":     peerKind,
@@ -459,7 +460,7 @@ func (c *WeComBotChannel) sendWebhookReply(ctx context.Context, userID, content
 
 // handleHealth handles health check requests
 func (c *WeComBotChannel) handleHealth(w http.ResponseWriter, r *http.Request) {
-	status := map[string]interface{}{
+	status := map[string]any{
 		"status":  "ok",
 		"running": c.IsRunning(),
 	}
diff --git a/pkg/channels/wecom/bot_test.go b/pkg/channels/wecom/bot_test.go
index 460e0058f..328b145c2 100644
--- a/pkg/channels/wecom/bot_test.go
+++ b/pkg/channels/wecom/bot_test.go
@@ -18,7 +18,6 @@ import (
 	"testing"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
-	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 )
 
@@ -196,10 +195,8 @@ func TestWeComBotVerifySignature(t *testing.T) {
 			Token:      "",
 			WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
 		}
-		base := channels.NewBaseChannel("wecom", cfgEmpty, msgBus, cfgEmpty.AllowFrom)
 		chEmpty := &WeComBotChannel{
-			BaseChannel: base,
-			config:      cfgEmpty,
+			config: cfgEmpty,
 		}
 
 		if !verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
@@ -356,7 +353,11 @@ func TestWeComBotHandleVerification(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, encryptedEchostr)
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleVerification(context.Background(), w, req)
@@ -386,7 +387,11 @@ func TestWeComBotHandleVerification(t *testing.T) {
 		timestamp := "1234567890"
 		nonce := "test_nonce"
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encryptedEchostr,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleVerification(context.Background(), w, req)
@@ -410,14 +415,14 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 	t.Run("valid direct message callback", func(t *testing.T) {
 		// Create JSON message for direct chat (single)
 		jsonMsg := `{
-					"msgid": "test_msg_id_123",
-					"aibotid": "test_aibot_id",
-					"chattype": "single",
-					"from": {"userid": "user123"},
-					"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-					"msgtype": "text",
-					"text": {"content": "Hello World"}
-				}`
+			"msgid": "test_msg_id_123",
+			"aibotid": "test_aibot_id",
+			"chattype": "single",
+			"from": {"userid": "user123"},
+			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			"msgtype": "text",
+			"text": {"content": "Hello World"}
+		}`
 
 		// Encrypt message
 		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
@@ -435,7 +440,11 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, encrypted)
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -451,15 +460,15 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 	t.Run("valid group message callback", func(t *testing.T) {
 		// Create JSON message for group chat
 		jsonMsg := `{
-					"msgid": "test_msg_id_456",
-					"aibotid": "test_aibot_id",
-					"chatid": "group_chat_id_123",
-					"chattype": "group",
-					"from": {"userid": "user456"},
-					"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-					"msgtype": "text",
-					"text": {"content": "Hello Group"}
-				}`
+			"msgid": "test_msg_id_456",
+			"aibotid": "test_aibot_id",
+			"chatid": "group_chat_id_123",
+			"chattype": "group",
+			"from": {"userid": "user456"},
+			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+			"msgtype": "text",
+			"text": {"content": "Hello Group"}
+		}`
 
 		// Encrypt message
 		encrypted, _ := encryptTestMessage(jsonMsg, aesKey)
@@ -477,7 +486,11 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, encrypted)
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -506,7 +519,11 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, "")
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, strings.NewReader("invalid xml"))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			strings.NewReader("invalid xml"),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -528,7 +545,11 @@ func TestWeComBotHandleMessageCallback(t *testing.T) {
 		timestamp := "1234567890"
 		nonce := "test_nonce"
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom?msg_signature=invalid_sig&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleMessageCallback(context.Background(), w, req)
@@ -623,7 +644,11 @@ func TestWeComBotHandleWebhook(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, encoded)
 
-		req := httptest.NewRequest(http.MethodGet, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded, nil)
+		req := httptest.NewRequest(
+			http.MethodGet,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce+"&echostr="+encoded,
+			nil,
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleWebhook(w, req)
@@ -646,7 +671,11 @@ func TestWeComBotHandleWebhook(t *testing.T) {
 		nonce := "test_nonce"
 		signature := generateSignature("test_token", timestamp, nonce, encryptedWrapper.Encrypt)
 
-		req := httptest.NewRequest(http.MethodPost, "/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce, bytes.NewReader(wrapperData))
+		req := httptest.NewRequest(
+			http.MethodPost,
+			"/webhook/wecom?msg_signature="+signature+"&timestamp="+timestamp+"&nonce="+nonce,
+			bytes.NewReader(wrapperData),
+		)
 		w := httptest.NewRecorder()
 
 		ch.handleWebhook(w, req)
@@ -713,15 +742,15 @@ func TestWeComBotReplyMessage(t *testing.T) {
 
 func TestWeComBotMessageStructure(t *testing.T) {
 	jsonData := `{
-			"msgid": "test_msg_id_123",
-			"aibotid": "test_aibot_id",
-			"chatid": "group_chat_id_123",
-			"chattype": "group",
-			"from": {"userid": "user123"},
-			"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
-			"msgtype": "text",
-			"text": {"content": "Hello World"}
-		}`
+		"msgid": "test_msg_id_123",
+		"aibotid": "test_aibot_id",
+		"chatid": "group_chat_id_123",
+		"chattype": "group",
+		"from": {"userid": "user123"},
+		"response_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
+		"msgtype": "text",
+		"text": {"content": "Hello World"}
+	}`
 
 	var msg WeComBotMessage
 	err := json.Unmarshal([]byte(jsonData), &msg)
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index 1ac256766..7e8f13ab6 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -87,7 +87,7 @@ func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("whatsapp connection not established")
 	}
 
-	payload := map[string]interface{}{
+	payload := map[string]any{
 		"type":    "message",
 		"to":      msg.ChatID,
 		"content": msg.Content,
@@ -127,7 +127,7 @@ func (c *WhatsAppChannel) listen(ctx context.Context) {
 				continue
 			}
 
-			var msg map[string]interface{}
+			var msg map[string]any
 			if err := json.Unmarshal(message, &msg); err != nil {
 				log.Printf("Failed to unmarshal WhatsApp message: %v", err)
 				continue
@@ -145,7 +145,7 @@ func (c *WhatsAppChannel) listen(ctx context.Context) {
 	}
 }
 
-func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]interface{}) {
+func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
 	senderID, ok := msg["from"].(string)
 	if !ok {
 		return
@@ -162,7 +162,7 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]interface{}) {
 	}
 
 	var mediaPaths []string
-	if mediaData, ok := msg["media"].([]interface{}); ok {
+	if mediaData, ok := msg["media"].([]any); ok {
 		mediaPaths = make([]string, 0, len(mediaData))
 		for _, m := range mediaData {
 			if path, ok := m.(string); ok {

From 153198e0f35fef47d44c82af0b4d46ad3e411ff0 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sun, 22 Feb 2026 21:57:12 +0800
Subject: [PATCH 34/52] refactor(bus,channels): promote peer and messageID from
 metadata to structured fields

Add bus.Peer struct and explicit Peer/MessageID fields to InboundMessage,
replacing the implicit peer_kind/peer_id/message_id metadata convention.

- Add Peer{Kind, ID} type to pkg/bus/types.go
- Extend InboundMessage with Peer and MessageID fields
- Change BaseChannel.HandleMessage signature to accept peer and messageID
- Adapt all 12 channel implementations to pass structured peer/messageID
- Simplify agent extractPeer() to read msg.Peer directly
- extractParentPeer unchanged (parent_peer still via metadata)
---
 pkg/agent/loop.go                 | 11 +++++------
 pkg/bus/types.go                  |  8 ++++++++
 pkg/channels/base.go              | 21 ++++++++++++++-------
 pkg/channels/dingtalk/dingtalk.go |  9 ++++-----
 pkg/channels/discord/discord.go   |  7 +++----
 pkg/channels/feishu/feishu_32.go  |  4 +++-
 pkg/channels/feishu/feishu_64.go  | 14 +++++++-------
 pkg/channels/line/line.go         | 10 ++++------
 pkg/channels/maixcam/maixcam.go   |  4 +---
 pkg/channels/onebot/onebot.go     | 14 ++++++--------
 pkg/channels/qq/qq.go             | 31 ++++++++++++++++++++-----------
 pkg/channels/slack/slack.go       | 16 +++++++---------
 pkg/channels/telegram/telegram.go | 16 ++++++++++++----
 pkg/channels/wecom/app.go         |  7 ++++---
 pkg/channels/wecom/bot.go         |  6 +++---
 pkg/channels/whatsapp/whatsapp.go | 14 +++++++-------
 16 files changed, 108 insertions(+), 84 deletions(-)

diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index bf229ad74..d8ea3b091 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -1122,21 +1122,20 @@ func (al *AgentLoop) handleCommand(ctx context.Context, msg bus.InboundMessage)
 	return "", false
 }
 
-// extractPeer extracts the routing peer from inbound message metadata.
+// extractPeer extracts the routing peer from the inbound message's structured Peer field.
 func extractPeer(msg bus.InboundMessage) *routing.RoutePeer {
-	peerKind := msg.Metadata["peer_kind"]
-	if peerKind == "" {
+	if msg.Peer.Kind == "" {
 		return nil
 	}
-	peerID := msg.Metadata["peer_id"]
+	peerID := msg.Peer.ID
 	if peerID == "" {
-		if peerKind == "direct" {
+		if msg.Peer.Kind == "direct" {
 			peerID = msg.SenderID
 		} else {
 			peerID = msg.ChatID
 		}
 	}
-	return &routing.RoutePeer{Kind: peerKind, ID: peerID}
+	return &routing.RoutePeer{Kind: msg.Peer.Kind, ID: peerID}
 }
 
 // extractParentPeer extracts the parent peer (reply-to) from inbound message metadata.
diff --git a/pkg/bus/types.go b/pkg/bus/types.go
index 44f9181a5..081f13a0b 100644
--- a/pkg/bus/types.go
+++ b/pkg/bus/types.go
@@ -1,11 +1,19 @@
 package bus
 
+// Peer identifies the routing peer for a message (direct, group, channel, etc.)
+type Peer struct {
+	Kind string `json:"kind"` // "direct" | "group" | "channel" | ""
+	ID   string `json:"id"`
+}
+
 type InboundMessage struct {
 	Channel    string            `json:"channel"`
 	SenderID   string            `json:"sender_id"`
 	ChatID     string            `json:"chat_id"`
 	Content    string            `json:"content"`
 	Media      []string          `json:"media,omitempty"`
+	Peer       Peer              `json:"peer"`                 // routing peer
+	MessageID  string            `json:"message_id,omitempty"` // platform message ID
 	SessionKey string            `json:"session_key"`
 	Metadata   map[string]string `json:"metadata,omitempty"`
 }
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index 5d77c6c0d..5e603f0d4 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -81,18 +81,25 @@ func (c *BaseChannel) IsAllowed(senderID string) bool {
 	return false
 }
 
-func (c *BaseChannel) HandleMessage(senderID, chatID, content string, media []string, metadata map[string]string) {
+func (c *BaseChannel) HandleMessage(
+	peer bus.Peer,
+	messageID, senderID, chatID, content string,
+	media []string,
+	metadata map[string]string,
+) {
 	if !c.IsAllowed(senderID) {
 		return
 	}
 
 	msg := bus.InboundMessage{
-		Channel:  c.name,
-		SenderID: senderID,
-		ChatID:   chatID,
-		Content:  content,
-		Media:    media,
-		Metadata: metadata,
+		Channel:   c.name,
+		SenderID:  senderID,
+		ChatID:    chatID,
+		Content:   content,
+		Media:     media,
+		Peer:      peer,
+		MessageID: messageID,
+		Metadata:  metadata,
 	}
 
 	c.bus.PublishInbound(msg)
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index afc0de47f..a8aee65d6 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -160,12 +160,11 @@ func (c *DingTalkChannel) onChatBotMessageReceived(
 		"session_webhook":   data.SessionWebhook,
 	}
 
+	var peer bus.Peer
 	if data.ConversationType == "1" {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
+		peer = bus.Peer{Kind: "direct", ID: senderID}
 	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = data.ConversationId
+		peer = bus.Peer{Kind: "group", ID: data.ConversationId}
 	}
 
 	logger.DebugCF("dingtalk", "Received message", map[string]any{
@@ -175,7 +174,7 @@ func (c *DingTalkChannel) onChatBotMessageReceived(
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(peer, "", senderID, chatID, content, nil, metadata)
 
 	// Return nil to indicate we've handled the message asynchronously
 	// The response will be sent through the message bus
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index b83ac28fd..416a94710 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -294,19 +294,18 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		peerID = senderID
 	}
 
+	peer := bus.Peer{Kind: peerKind, ID: peerID}
+
 	metadata := map[string]string{
-		"message_id":   m.ID,
 		"user_id":      senderID,
 		"username":     m.Author.Username,
 		"display_name": senderName,
 		"guild_id":     m.GuildID,
 		"channel_id":   m.ChannelID,
 		"is_dm":        fmt.Sprintf("%t", m.GuildID == ""),
-		"peer_kind":    peerKind,
-		"peer_id":      peerID,
 	}
 
-	c.HandleMessage(senderID, m.ChannelID, content, mediaPaths, metadata)
+	c.HandleMessage(peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata)
 }
 
 // startTyping starts a continuous typing indicator loop for the given chatID.
diff --git a/pkg/channels/feishu/feishu_32.go b/pkg/channels/feishu/feishu_32.go
index 14711e49e..d0ec758c6 100644
--- a/pkg/channels/feishu/feishu_32.go
+++ b/pkg/channels/feishu/feishu_32.go
@@ -18,7 +18,9 @@ type FeishuChannel struct {
 
 // 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")
+	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
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index aa4e141c4..d67823974 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -153,8 +153,9 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 	}
 
 	metadata := map[string]string{}
-	if messageID := stringValue(message.MessageId); messageID != "" {
-		metadata["message_id"] = messageID
+	messageID := ""
+	if mid := stringValue(message.MessageId); mid != "" {
+		messageID = mid
 	}
 	if messageType := stringValue(message.MessageType); messageType != "" {
 		metadata["message_type"] = messageType
@@ -167,12 +168,11 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 	}
 
 	chatType := stringValue(message.ChatType)
+	var peer bus.Peer
 	if chatType == "p2p" {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
+		peer = bus.Peer{Kind: "direct", ID: senderID}
 	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
+		peer = bus.Peer{Kind: "group", ID: chatID}
 	}
 
 	logger.InfoCF("feishu", "Feishu message received", map[string]any{
@@ -181,7 +181,7 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 		"preview":   utils.Truncate(content, 80),
 	})
 
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(peer, messageID, senderID, chatID, content, nil, metadata)
 	return nil
 }
 
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 4e1d0dfd3..96297e2cd 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -364,15 +364,13 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	metadata := map[string]string{
 		"platform":    "line",
 		"source_type": event.Source.Type,
-		"message_id":  msg.ID,
 	}
 
+	var peer bus.Peer
 	if isGroup {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
+		peer = bus.Peer{Kind: "group", ID: chatID}
 	} else {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
+		peer = bus.Peer{Kind: "direct", ID: senderID}
 	}
 
 	logger.DebugCF("line", "Received message", map[string]any{
@@ -386,7 +384,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	// Show typing/loading indicator (requires user ID, not group ID)
 	c.sendLoading(senderID)
 
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(peer, msg.ID, senderID, chatID, content, mediaPaths, metadata)
 }
 
 // isBotMentioned checks if the bot is mentioned in the message.
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index a7bff55e0..280098dda 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -171,11 +171,9 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
 		"y":         fmt.Sprintf("%.0f", y),
 		"w":         fmt.Sprintf("%.0f", w),
 		"h":         fmt.Sprintf("%.0f", h),
-		"peer_kind": "channel",
-		"peer_id":   "default",
 	}
 
-	c.HandleMessage(senderID, chatID, content, []string{}, metadata)
+	c.HandleMessage(bus.Peer{Kind: "channel", ID: "default"}, "", senderID, chatID, content, []string{}, metadata)
 }
 
 func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) {
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 3d2e64e2a..642eebd1d 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -856,9 +856,9 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	senderID := strconv.FormatInt(userID, 10)
 	var chatID string
 
-	metadata := map[string]string{
-		"message_id": messageID,
-	}
+	var peer bus.Peer
+
+	metadata := map[string]string{}
 
 	if parsed.ReplyTo != "" {
 		metadata["reply_to_message_id"] = parsed.ReplyTo
@@ -867,14 +867,12 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	switch raw.MessageType {
 	case "private":
 		chatID = "private:" + senderID
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
+		peer = bus.Peer{Kind: "direct", ID: senderID}
 
 	case "group":
 		groupIDStr := strconv.FormatInt(groupID, 10)
 		chatID = "group:" + groupIDStr
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = groupIDStr
+		peer = bus.Peer{Kind: "group", ID: groupIDStr}
 		metadata["group_id"] = groupIDStr
 
 		senderUserID, _ := parseJSONInt64(sender.UserID)
@@ -929,7 +927,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		c.pendingEmojiMsg.Store(chatID, messageID)
 	}
 
-	c.HandleMessage(senderID, chatID, content, parsed.Media, metadata)
+	c.HandleMessage(peer, messageID, senderID, chatID, content, parsed.Media, metadata)
 }
 
 func (c *OneBotChannel) isDuplicate(messageID string) bool {
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 2a95bbd06..429e23cbf 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -164,13 +164,17 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 		})
 
 		// 转发到消息总线
-		metadata := map[string]string{
-			"message_id": data.ID,
-			"peer_kind":  "direct",
-			"peer_id":    senderID,
-		}
+		metadata := map[string]string{}
 
-		c.HandleMessage(senderID, senderID, content, []string{}, metadata)
+		c.HandleMessage(
+			bus.Peer{Kind: "direct", ID: senderID},
+			data.ID,
+			senderID,
+			senderID,
+			content,
+			[]string{},
+			metadata,
+		)
 
 		return nil
 	}
@@ -208,13 +212,18 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 
 		// 转发到消息总线（使用 GroupID 作为 ChatID）
 		metadata := map[string]string{
-			"message_id": data.ID,
-			"group_id":   data.GroupID,
-			"peer_kind":  "group",
-			"peer_id":    data.GroupID,
+			"group_id": data.GroupID,
 		}
 
-		c.HandleMessage(senderID, data.GroupID, content, []string{}, metadata)
+		c.HandleMessage(
+			bus.Peer{Kind: "group", ID: data.GroupID},
+			data.ID,
+			senderID,
+			data.GroupID,
+			content,
+			[]string{},
+			metadata,
+		)
 
 		return nil
 	}
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index cafe53103..b459a7140 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -284,13 +284,13 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		peerID = senderID
 	}
 
+	peer := bus.Peer{Kind: peerKind, ID: peerID}
+
 	metadata := map[string]string{
 		"message_ts": messageTS,
 		"channel_id": channelID,
 		"thread_ts":  threadTS,
 		"platform":   "slack",
-		"peer_kind":  peerKind,
-		"peer_id":    peerID,
 		"team_id":    c.teamID,
 	}
 
@@ -301,7 +301,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		"has_thread": threadTS != "",
 	})
 
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(peer, messageTS, senderID, chatID, content, mediaPaths, metadata)
 }
 
 func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
@@ -351,18 +351,18 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		mentionPeerID = senderID
 	}
 
+	mentionPeer := bus.Peer{Kind: mentionPeerKind, ID: mentionPeerID}
+
 	metadata := map[string]string{
 		"message_ts": messageTS,
 		"channel_id": channelID,
 		"thread_ts":  threadTS,
 		"platform":   "slack",
 		"is_mention": "true",
-		"peer_kind":  mentionPeerKind,
-		"peer_id":    mentionPeerID,
 		"team_id":    c.teamID,
 	}
 
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(mentionPeer, messageTS, senderID, chatID, content, nil, metadata)
 }
 
 func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
@@ -396,8 +396,6 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		"platform":   "slack",
 		"is_command": "true",
 		"trigger_id": cmd.TriggerID,
-		"peer_kind":  "channel",
-		"peer_id":    channelID,
 		"team_id":    c.teamID,
 	}
 
@@ -407,7 +405,7 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		"text":      utils.Truncate(content, 50),
 	})
 
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(bus.Peer{Kind: "channel", ID: channelID}, "", senderID, chatID, content, nil, metadata)
 }
 
 func (c *SlackChannel) downloadSlackFile(file slack.File) string {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 7619440e2..5703000b4 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -362,17 +362,25 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		peerID = fmt.Sprintf("%d", chatID)
 	}
 
+	peer := bus.Peer{Kind: peerKind, ID: peerID}
+	messageID := fmt.Sprintf("%d", message.MessageID)
+
 	metadata := map[string]string{
-		"message_id": fmt.Sprintf("%d", message.MessageID),
 		"user_id":    fmt.Sprintf("%d", user.ID),
 		"username":   user.Username,
 		"first_name": user.FirstName,
 		"is_group":   fmt.Sprintf("%t", message.Chat.Type != "private"),
-		"peer_kind":  peerKind,
-		"peer_id":    peerID,
 	}
 
-	c.HandleMessage(fmt.Sprintf("%d", user.ID), fmt.Sprintf("%d", chatID), content, mediaPaths, metadata)
+	c.HandleMessage(
+		peer,
+		messageID,
+		fmt.Sprintf("%d", user.ID),
+		fmt.Sprintf("%d", chatID),
+		content,
+		mediaPaths,
+		metadata,
+	)
 	return nil
 }
 
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index f3557d60f..873431d3c 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -425,6 +425,9 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 
 	// Build metadata
 	// WeCom App only supports direct messages (private chat)
+	peer := bus.Peer{Kind: "direct", ID: senderID}
+	messageID := fmt.Sprintf("%d", msg.MsgId)
+
 	metadata := map[string]string{
 		"msg_type":    msg.MsgType,
 		"msg_id":      fmt.Sprintf("%d", msg.MsgId),
@@ -432,8 +435,6 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 		"platform":    "wecom_app",
 		"media_id":    msg.MediaId,
 		"create_time": fmt.Sprintf("%d", msg.CreateTime),
-		"peer_kind":   "direct",
-		"peer_id":     senderID,
 	}
 
 	content := msg.Content
@@ -445,7 +446,7 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(peer, messageID, senderID, chatID, content, nil, metadata)
 }
 
 // tokenRefreshLoop periodically refreshes the access token
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 17ee2107f..3a8a16c43 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -378,12 +378,12 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 	}
 
 	// Build metadata
+	peer := bus.Peer{Kind: peerKind, ID: peerID}
+
 	metadata := map[string]string{
 		"msg_type":     msg.MsgType,
 		"msg_id":       msg.MsgID,
 		"platform":     "wecom",
-		"peer_kind":    peerKind,
-		"peer_id":      peerID,
 		"response_url": msg.ResponseURL,
 	}
 	if isGroupChat {
@@ -400,7 +400,7 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(senderID, chatID, content, nil, metadata)
+	c.HandleMessage(peer, msg.MsgID, senderID, chatID, content, nil, metadata)
 }
 
 // sendWebhookReply sends a reply using the webhook URL
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index 7e8f13ab6..1a5401172 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -172,22 +172,22 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
 	}
 
 	metadata := make(map[string]string)
-	if messageID, ok := msg["id"].(string); ok {
-		metadata["message_id"] = messageID
+	var messageID string
+	if mid, ok := msg["id"].(string); ok {
+		messageID = mid
 	}
 	if userName, ok := msg["from_name"].(string); ok {
 		metadata["user_name"] = userName
 	}
 
+	var peer bus.Peer
 	if chatID == senderID {
-		metadata["peer_kind"] = "direct"
-		metadata["peer_id"] = senderID
+		peer = bus.Peer{Kind: "direct", ID: senderID}
 	} else {
-		metadata["peer_kind"] = "group"
-		metadata["peer_id"] = chatID
+		peer = bus.Peer{Kind: "group", ID: chatID}
 	}
 
 	log.Printf("WhatsApp message from %s: %s...", senderID, utils.Truncate(content, 50))
 
-	c.HandleMessage(senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(peer, messageID, senderID, chatID, content, mediaPaths, metadata)
 }

From b6161aec3f49beae2acfc597476e20d0e4b8732c Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sun, 22 Feb 2026 22:25:07 +0800
Subject: [PATCH 35/52] refactor(channels): unify Start/Stop lifecycle and fix
 goroutine/context leaks

- OneBot: remove close(ch) race in Stop() pending cleanup; add WriteDeadline to Send/sendAPIRequest
- Telegram: add cancelCtx; Stop() now calls bh.Stop(), cancel(), and cleans up thinking CancelFuncs
- Discord: add cancelCtx via WithCancel; Stop() calls cancel(); remove unused getContext()
- WhatsApp: add cancelCtx; Send() adds WriteDeadline; replace stdlib log with project logger
- MaixCam: add cancelCtx; Send() adds WriteDeadline; Stop() calls cancel() before closing
---
 pkg/channels/discord/discord.go   | 17 ++++++------
 pkg/channels/maixcam/maixcam.go   | 25 +++++++++++++----
 pkg/channels/onebot/onebot.go     |  7 +++--
 pkg/channels/telegram/telegram.go | 35 +++++++++++++++++++----
 pkg/channels/whatsapp/whatsapp.go | 46 +++++++++++++++++++++++--------
 5 files changed, 96 insertions(+), 34 deletions(-)

diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 416a94710..faf1e1358 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -29,6 +29,7 @@ type DiscordChannel struct {
 	config      config.DiscordConfig
 	transcriber *voice.GroqTranscriber
 	ctx         context.Context
+	cancel      context.CancelFunc
 	typingMu    sync.Mutex
 	typingStop  map[string]chan struct{} // chatID → stop signal
 	botUserID   string                   // stored for mention checking
@@ -56,17 +57,10 @@ func (c *DiscordChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
 	c.transcriber = transcriber
 }
 
-func (c *DiscordChannel) getContext() context.Context {
-	if c.ctx == nil {
-		return context.Background()
-	}
-	return c.ctx
-}
-
 func (c *DiscordChannel) Start(ctx context.Context) error {
 	logger.InfoC("discord", "Starting Discord bot")
 
-	c.ctx = ctx
+	c.ctx, c.cancel = context.WithCancel(ctx)
 
 	// Get bot user ID before opening session to avoid race condition
 	botUser, err := c.session.User("@me")
@@ -103,6 +97,11 @@ func (c *DiscordChannel) Stop(ctx context.Context) error {
 	}
 	c.typingMu.Unlock()
 
+	// Cancel our context so typing goroutines using c.ctx.Done() exit
+	if c.cancel != nil {
+		c.cancel()
+	}
+
 	if err := c.session.Close(); err != nil {
 		return fmt.Errorf("failed to close discord session: %w", err)
 	}
@@ -236,7 +235,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 
 				transcribedText := ""
 				if c.transcriber != nil && c.transcriber.IsAvailable() {
-					ctx, cancel := context.WithTimeout(c.getContext(), transcriptionTimeout)
+					ctx, cancel := context.WithTimeout(c.ctx, transcriptionTimeout)
 					result, err := c.transcriber.Transcribe(ctx, localPath)
 					cancel() // Release context resources immediately to avoid leaks in for loop
 
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index 280098dda..05213b095 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net"
 	"sync"
+	"time"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
@@ -17,6 +18,8 @@ type MaixCamChannel struct {
 	*channels.BaseChannel
 	config     config.MaixCamConfig
 	listener   net.Listener
+	ctx        context.Context
+	cancel     context.CancelFunc
 	clients    map[net.Conn]bool
 	clientsMux sync.RWMutex
 }
@@ -41,9 +44,12 @@ func NewMaixCamChannel(cfg config.MaixCamConfig, bus *bus.MessageBus) (*MaixCamC
 func (c *MaixCamChannel) Start(ctx context.Context) error {
 	logger.InfoC("maixcam", "Starting MaixCam channel server")
 
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
 	addr := fmt.Sprintf("%s:%d", c.config.Host, c.config.Port)
 	listener, err := net.Listen("tcp", addr)
 	if err != nil {
+		c.cancel()
 		return fmt.Errorf("failed to listen on %s: %w", addr, err)
 	}
 
@@ -55,17 +61,17 @@ func (c *MaixCamChannel) Start(ctx context.Context) error {
 		"port": c.config.Port,
 	})
 
-	go c.acceptConnections(ctx)
+	go c.acceptConnections()
 
 	return nil
 }
 
-func (c *MaixCamChannel) acceptConnections(ctx context.Context) {
+func (c *MaixCamChannel) acceptConnections() {
 	logger.DebugC("maixcam", "Starting connection acceptor")
 
 	for {
 		select {
-		case <-ctx.Done():
+		case <-c.ctx.Done():
 			logger.InfoC("maixcam", "Stopping connection acceptor")
 			return
 		default:
@@ -87,12 +93,12 @@ func (c *MaixCamChannel) acceptConnections(ctx context.Context) {
 			c.clients[conn] = true
 			c.clientsMux.Unlock()
 
-			go c.handleConnection(conn, ctx)
+			go c.handleConnection(conn)
 		}
 	}
 }
 
-func (c *MaixCamChannel) handleConnection(conn net.Conn, ctx context.Context) {
+func (c *MaixCamChannel) handleConnection(conn net.Conn) {
 	logger.DebugC("maixcam", "Handling MaixCam connection")
 
 	defer func() {
@@ -107,7 +113,7 @@ func (c *MaixCamChannel) handleConnection(conn net.Conn, ctx context.Context) {
 
 	for {
 		select {
-		case <-ctx.Done():
+		case <-c.ctx.Done():
 			return
 		default:
 			var msg MaixCamMessage
@@ -186,6 +192,11 @@ func (c *MaixCamChannel) Stop(ctx context.Context) error {
 	logger.InfoC("maixcam", "Stopping MaixCam channel")
 	c.SetRunning(false)
 
+	// Cancel context first to signal goroutines to exit
+	if c.cancel != nil {
+		c.cancel()
+	}
+
 	if c.listener != nil {
 		c.listener.Close()
 	}
@@ -229,6 +240,7 @@ func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 
 	var sendErr error
 	for conn := range c.clients {
+		_ = conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 		if _, err := conn.Write(data); err != nil {
 			logger.ErrorCF("maixcam", "Failed to send to client", map[string]any{
 				"client": conn.RemoteAddr().String(),
@@ -236,6 +248,7 @@ func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 			})
 			sendErr = err
 		}
+		_ = conn.SetWriteDeadline(time.Time{})
 	}
 
 	return sendErr
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 642eebd1d..4f35888ca 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -298,7 +298,9 @@ func (c *OneBotChannel) sendAPIRequest(action string, params any, timeout time.D
 	}
 
 	c.writeMu.Lock()
+	_ = conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 	err = conn.WriteMessage(websocket.TextMessage, data)
+	_ = conn.SetWriteDeadline(time.Time{})
 	c.writeMu.Unlock()
 
 	if err != nil {
@@ -354,8 +356,7 @@ func (c *OneBotChannel) Stop(ctx context.Context) error {
 	}
 
 	c.pendingMu.Lock()
-	for echo, ch := range c.pending {
-		close(ch)
+	for echo := range c.pending {
 		delete(c.pending, echo)
 	}
 	c.pendingMu.Unlock()
@@ -402,7 +403,9 @@ func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 	}
 
 	c.writeMu.Lock()
+	_ = conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 	err = conn.WriteMessage(websocket.TextMessage, data)
+	_ = conn.SetWriteDeadline(time.Time{})
 	c.writeMu.Unlock()
 
 	if err != nil {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 5703000b4..af825ddc9 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -27,10 +27,13 @@ import (
 type TelegramChannel struct {
 	*channels.BaseChannel
 	bot          *telego.Bot
+	bh           *telegohandler.BotHandler
 	commands     TelegramCommander
 	config       *config.Config
 	chatIDs      map[string]int64
 	transcriber  *voice.GroqTranscriber
+	ctx          context.Context
+	cancel       context.CancelFunc
 	placeholders sync.Map // chatID -> messageID
 	stopThinking sync.Map // chatID -> thinkingCancel
 }
@@ -94,17 +97,22 @@ func (c *TelegramChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
 func (c *TelegramChannel) Start(ctx context.Context) error {
 	logger.InfoC("telegram", "Starting Telegram bot (polling mode)...")
 
-	updates, err := c.bot.UpdatesViaLongPolling(ctx, &telego.GetUpdatesParams{
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	updates, err := c.bot.UpdatesViaLongPolling(c.ctx, &telego.GetUpdatesParams{
 		Timeout: 30,
 	})
 	if err != nil {
+		c.cancel()
 		return fmt.Errorf("failed to start long polling: %w", err)
 	}
 
 	bh, err := telegohandler.NewBotHandler(c.bot, updates)
 	if err != nil {
+		c.cancel()
 		return fmt.Errorf("failed to create bot handler: %w", err)
 	}
+	c.bh = bh
 
 	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
 		c.commands.Help(ctx, message)
@@ -133,17 +141,32 @@ func (c *TelegramChannel) Start(ctx context.Context) error {
 
 	go bh.Start()
 
-	go func() {
-		<-ctx.Done()
-		bh.Stop()
-	}()
-
 	return nil
 }
 
 func (c *TelegramChannel) Stop(ctx context.Context) error {
 	logger.InfoC("telegram", "Stopping Telegram bot...")
 	c.SetRunning(false)
+
+	// Clean up all thinking cancel functions to avoid context leaks
+	c.stopThinking.Range(func(key, value any) bool {
+		if cf, ok := value.(*thinkingCancel); ok && cf != nil {
+			cf.Cancel()
+		}
+		c.stopThinking.Delete(key)
+		return true
+	})
+
+	// Stop the bot handler
+	if c.bh != nil {
+		c.bh.Stop()
+	}
+
+	// Cancel our context (stops long polling)
+	if c.cancel != nil {
+		c.cancel()
+	}
+
 	return nil
 }
 
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index 1a5401172..cbc82fd09 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"sync"
 	"time"
 
@@ -13,6 +12,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
@@ -21,6 +21,8 @@ type WhatsAppChannel struct {
 	conn      *websocket.Conn
 	config    config.WhatsAppConfig
 	url       string
+	ctx       context.Context
+	cancel    context.CancelFunc
 	mu        sync.Mutex
 	connected bool
 }
@@ -37,13 +39,18 @@ func NewWhatsAppChannel(cfg config.WhatsAppConfig, bus *bus.MessageBus) (*WhatsA
 }
 
 func (c *WhatsAppChannel) Start(ctx context.Context) error {
-	log.Printf("Starting WhatsApp channel connecting to %s...", c.url)
+	logger.InfoCF("whatsapp", "Starting WhatsApp channel", map[string]any{
+		"bridge_url": c.url,
+	})
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
 
 	dialer := websocket.DefaultDialer
 	dialer.HandshakeTimeout = 10 * time.Second
 
 	conn, _, err := dialer.Dial(c.url, nil)
 	if err != nil {
+		c.cancel()
 		return fmt.Errorf("failed to connect to WhatsApp bridge: %w", err)
 	}
 
@@ -53,22 +60,29 @@ func (c *WhatsAppChannel) Start(ctx context.Context) error {
 	c.mu.Unlock()
 
 	c.SetRunning(true)
-	log.Println("WhatsApp channel connected")
+	logger.InfoC("whatsapp", "WhatsApp channel connected")
 
-	go c.listen(ctx)
+	go c.listen()
 
 	return nil
 }
 
 func (c *WhatsAppChannel) Stop(ctx context.Context) error {
-	log.Println("Stopping WhatsApp channel...")
+	logger.InfoC("whatsapp", "Stopping WhatsApp channel...")
+
+	// Cancel context first to signal listen goroutine to exit
+	if c.cancel != nil {
+		c.cancel()
+	}
 
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	if c.conn != nil {
 		if err := c.conn.Close(); err != nil {
-			log.Printf("Error closing WhatsApp connection: %v", err)
+			logger.ErrorCF("whatsapp", "Error closing WhatsApp connection", map[string]any{
+				"error": err.Error(),
+			})
 		}
 		c.conn = nil
 	}
@@ -98,17 +112,20 @@ func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("failed to marshal message: %w", err)
 	}
 
+	_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 	if err := c.conn.WriteMessage(websocket.TextMessage, data); err != nil {
+		_ = c.conn.SetWriteDeadline(time.Time{})
 		return fmt.Errorf("failed to send message: %w", err)
 	}
+	_ = c.conn.SetWriteDeadline(time.Time{})
 
 	return nil
 }
 
-func (c *WhatsAppChannel) listen(ctx context.Context) {
+func (c *WhatsAppChannel) listen() {
 	for {
 		select {
-		case <-ctx.Done():
+		case <-c.ctx.Done():
 			return
 		default:
 			c.mu.Lock()
@@ -122,14 +139,18 @@ func (c *WhatsAppChannel) listen(ctx context.Context) {
 
 			_, message, err := conn.ReadMessage()
 			if err != nil {
-				log.Printf("WhatsApp read error: %v", err)
+				logger.ErrorCF("whatsapp", "WhatsApp read error", map[string]any{
+					"error": err.Error(),
+				})
 				time.Sleep(2 * time.Second)
 				continue
 			}
 
 			var msg map[string]any
 			if err := json.Unmarshal(message, &msg); err != nil {
-				log.Printf("Failed to unmarshal WhatsApp message: %v", err)
+				logger.ErrorCF("whatsapp", "Failed to unmarshal WhatsApp message", map[string]any{
+					"error": err.Error(),
+				})
 				continue
 			}
 
@@ -187,7 +208,10 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
 		peer = bus.Peer{Kind: "group", ID: chatID}
 	}
 
-	log.Printf("WhatsApp message from %s: %s...", senderID, utils.Truncate(content, 50))
+	logger.InfoCF("whatsapp", "WhatsApp message received", map[string]any{
+		"sender":  senderID,
+		"preview": utils.Truncate(content, 50),
+	})
 
 	c.HandleMessage(peer, messageID, senderID, chatID, content, mediaPaths, metadata)
 }

From 70019836b5185c4dd269258d0c6135e2b9ed1029 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sun, 22 Feb 2026 22:46:29 +0800
Subject: [PATCH 36/52] refactor(channels): unify message splitting and add
 per-channel worker queues

Move message splitting from individual channels (Discord) to the Manager
layer via per-channel worker goroutines. Each channel now declares its
max message length through BaseChannelOption/MessageLengthProvider, and
the Manager automatically splits oversized outbound messages before
dispatch. This prevents one slow channel from blocking all others.

- Add WithMaxMessageLength option and MessageLengthProvider interface
- Set platform-specific limits (Discord 2000, Telegram 4096, Slack 40000, etc.)
- Convert SplitMessage to rune-aware counting for correct Unicode handling
- Replace single dispatcher goroutine with per-channel buffered worker queues
- Remove Discord's internal SplitMessage call (now handled centrally)
---
 pkg/channels/base.go              |  50 ++++++++++---
 pkg/channels/dingtalk/dingtalk.go |   2 +-
 pkg/channels/discord/discord.go   |  15 +---
 pkg/channels/line/line.go         |   2 +-
 pkg/channels/manager.go           | 112 ++++++++++++++++++++++++++---
 pkg/channels/slack/slack.go       |   2 +-
 pkg/channels/telegram/telegram.go |   8 ++-
 pkg/channels/wecom/app.go         |   2 +-
 pkg/channels/wecom/bot.go         |   2 +-
 pkg/channels/whatsapp/whatsapp.go |   2 +-
 pkg/utils/message.go              | 114 ++++++++++++++++++------------
 pkg/utils/message_test.go         |  60 +++++++++++-----
 12 files changed, 272 insertions(+), 99 deletions(-)

diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index 5e603f0d4..f70145981 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -17,21 +17,55 @@ type Channel interface {
 	IsAllowed(senderID string) bool
 }
 
-type BaseChannel struct {
-	config    any
-	bus       *bus.MessageBus
-	running   atomic.Bool
-	name      string
-	allowList []string
+// BaseChannelOption is a functional option for configuring a BaseChannel.
+type BaseChannelOption func(*BaseChannel)
+
+// WithMaxMessageLength sets the maximum message length (in runes) for a channel.
+// Messages exceeding this limit will be automatically split by the Manager.
+// A value of 0 means no limit.
+func WithMaxMessageLength(n int) BaseChannelOption {
+	return func(c *BaseChannel) { c.maxMessageLength = n }
 }
 
-func NewBaseChannel(name string, config any, bus *bus.MessageBus, allowList []string) *BaseChannel {
-	return &BaseChannel{
+// MessageLengthProvider is an opt-in interface that channels implement
+// to advertise their maximum message length. The Manager uses this via
+// type assertion to decide whether to split outbound messages.
+type MessageLengthProvider interface {
+	MaxMessageLength() int
+}
+
+type BaseChannel struct {
+	config           any
+	bus              *bus.MessageBus
+	running          atomic.Bool
+	name             string
+	allowList        []string
+	maxMessageLength int
+}
+
+func NewBaseChannel(
+	name string,
+	config any,
+	bus *bus.MessageBus,
+	allowList []string,
+	opts ...BaseChannelOption,
+) *BaseChannel {
+	bc := &BaseChannel{
 		config:    config,
 		bus:       bus,
 		name:      name,
 		allowList: allowList,
 	}
+	for _, opt := range opts {
+		opt(bc)
+	}
+	return bc
+}
+
+// MaxMessageLength returns the maximum message length (in runes) for this channel.
+// A value of 0 means no limit.
+func (c *BaseChannel) MaxMessageLength() int {
+	return c.maxMessageLength
 }
 
 func (c *BaseChannel) Name() string {
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index a8aee65d6..e051add1f 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -38,7 +38,7 @@ func NewDingTalkChannel(cfg config.DingTalkConfig, messageBus *bus.MessageBus) (
 		return nil, fmt.Errorf("dingtalk client_id and client_secret are required")
 	}
 
-	base := channels.NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(20000))
 
 	return &DingTalkChannel{
 		BaseChannel:  base,
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index faf1e1358..623bc9f48 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -41,7 +41,7 @@ func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordC
 		return nil, fmt.Errorf("failed to create discord session: %w", err)
 	}
 
-	base := channels.NewBaseChannel("discord", cfg, bus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("discord", cfg, bus, cfg.AllowFrom, channels.WithMaxMessageLength(2000))
 
 	return &DiscordChannel{
 		BaseChannel: base,
@@ -121,20 +121,11 @@ func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 		return fmt.Errorf("channel ID is empty")
 	}
 
-	runes := []rune(msg.Content)
-	if len(runes) == 0 {
+	if len([]rune(msg.Content)) == 0 {
 		return nil
 	}
 
-	chunks := utils.SplitMessage(msg.Content, 2000) // Split messages into chunks, Discord length limit: 2000 chars
-
-	for _, chunk := range chunks {
-		if err := c.sendChunk(ctx, channelID, chunk); err != nil {
-			return err
-		}
-	}
-
-	return nil
+	return c.sendChunk(ctx, channelID, msg.Content)
 }
 
 func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 96297e2cd..9744e1848 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -60,7 +60,7 @@ func NewLINEChannel(cfg config.LINEConfig, messageBus *bus.MessageBus) (*LINECha
 		return nil, fmt.Errorf("line channel_secret and channel_access_token are required")
 	}
 
-	base := channels.NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(5000))
 
 	return &LINEChannel{
 		BaseChannel: base,
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 7baef058c..081d616da 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -15,10 +15,20 @@ import (
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/constants"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
+const defaultChannelQueueSize = 100
+
+type channelWorker struct {
+	ch    Channel
+	queue chan bus.OutboundMessage
+	done  chan struct{}
+}
+
 type Manager struct {
 	channels     map[string]Channel
+	workers      map[string]*channelWorker
 	bus          *bus.MessageBus
 	config       *config.Config
 	dispatchTask *asyncTask
@@ -32,6 +42,7 @@ type asyncTask struct {
 func NewManager(cfg *config.Config, messageBus *bus.MessageBus) (*Manager, error) {
 	m := &Manager{
 		channels: make(map[string]Channel),
+		workers:  make(map[string]*channelWorker),
 		bus:      messageBus,
 		config:   cfg,
 	}
@@ -63,6 +74,11 @@ func (m *Manager) initChannel(name, displayName string) {
 		})
 	} else {
 		m.channels[name] = ch
+		m.workers[name] = &channelWorker{
+			ch:    ch,
+			queue: make(chan bus.OutboundMessage, defaultChannelQueueSize),
+			done:  make(chan struct{}),
+		}
 		logger.InfoCF("channels", "Channel enabled successfully", map[string]any{
 			"channel": displayName,
 		})
@@ -141,8 +157,6 @@ func (m *Manager) StartAll(ctx context.Context) error {
 	dispatchCtx, cancel := context.WithCancel(ctx)
 	m.dispatchTask = &asyncTask{cancel: cancel}
 
-	go m.dispatchOutbound(dispatchCtx)
-
 	for name, channel := range m.channels {
 		logger.InfoCF("channels", "Starting channel", map[string]any{
 			"channel": name,
@@ -155,6 +169,14 @@ func (m *Manager) StartAll(ctx context.Context) error {
 		}
 	}
 
+	// Start per-channel workers
+	for name, w := range m.workers {
+		go m.runWorker(dispatchCtx, name, w)
+	}
+
+	// Start the dispatcher that reads from the bus and routes to workers
+	go m.dispatchOutbound(dispatchCtx)
+
 	logger.InfoC("channels", "All channels started")
 	return nil
 }
@@ -165,11 +187,21 @@ func (m *Manager) StopAll(ctx context.Context) error {
 
 	logger.InfoC("channels", "Stopping all channels")
 
+	// Cancel dispatcher first
 	if m.dispatchTask != nil {
 		m.dispatchTask.cancel()
 		m.dispatchTask = nil
 	}
 
+	// Close all worker queues and wait for them to drain
+	for _, w := range m.workers {
+		close(w.queue)
+	}
+	for _, w := range m.workers {
+		<-w.done
+	}
+
+	// Stop all channels
 	for name, channel := range m.channels {
 		logger.InfoCF("channels", "Stopping channel", map[string]any{
 			"channel": name,
@@ -186,6 +218,44 @@ func (m *Manager) StopAll(ctx context.Context) error {
 	return nil
 }
 
+// runWorker processes outbound messages for a single channel, splitting
+// messages that exceed the channel's maximum message length.
+func (m *Manager) runWorker(ctx context.Context, name string, w *channelWorker) {
+	defer close(w.done)
+	for {
+		select {
+		case msg, ok := <-w.queue:
+			if !ok {
+				return
+			}
+			maxLen := 0
+			if mlp, ok := w.ch.(MessageLengthProvider); ok {
+				maxLen = mlp.MaxMessageLength()
+			}
+			if maxLen > 0 && len([]rune(msg.Content)) > maxLen {
+				chunks := utils.SplitMessage(msg.Content, maxLen)
+				for _, chunk := range chunks {
+					chunkMsg := msg
+					chunkMsg.Content = chunk
+					if err := w.ch.Send(ctx, chunkMsg); err != nil {
+						logger.ErrorCF("channels", "Error sending chunk", map[string]any{
+							"channel": name, "error": err.Error(),
+						})
+					}
+				}
+			} else {
+				if err := w.ch.Send(ctx, msg); err != nil {
+					logger.ErrorCF("channels", "Error sending message", map[string]any{
+						"channel": name, "error": err.Error(),
+					})
+				}
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
 func (m *Manager) dispatchOutbound(ctx context.Context) {
 	logger.InfoC("channels", "Outbound dispatcher started")
 
@@ -206,7 +276,8 @@ func (m *Manager) dispatchOutbound(ctx context.Context) {
 			}
 
 			m.mu.RLock()
-			channel, exists := m.channels[msg.Channel]
+			_, exists := m.channels[msg.Channel]
+			w, wExists := m.workers[msg.Channel]
 			m.mu.RUnlock()
 
 			if !exists {
@@ -216,11 +287,12 @@ func (m *Manager) dispatchOutbound(ctx context.Context) {
 				continue
 			}
 
-			if err := channel.Send(ctx, msg); err != nil {
-				logger.ErrorCF("channels", "Error sending message to channel", map[string]any{
-					"channel": msg.Channel,
-					"error":   err.Error(),
-				})
+			if wExists {
+				select {
+				case w.queue <- msg:
+				case <-ctx.Done():
+					return
+				}
 			}
 		}
 	}
@@ -262,17 +334,28 @@ func (m *Manager) RegisterChannel(name string, channel Channel) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.channels[name] = channel
+	m.workers[name] = &channelWorker{
+		ch:    channel,
+		queue: make(chan bus.OutboundMessage, defaultChannelQueueSize),
+		done:  make(chan struct{}),
+	}
 }
 
 func (m *Manager) UnregisterChannel(name string) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
+	if w, ok := m.workers[name]; ok {
+		close(w.queue)
+		<-w.done
+	}
+	delete(m.workers, name)
 	delete(m.channels, name)
 }
 
 func (m *Manager) SendToChannel(ctx context.Context, channelName, chatID, content string) error {
 	m.mu.RLock()
-	channel, exists := m.channels[channelName]
+	_, exists := m.channels[channelName]
+	w, wExists := m.workers[channelName]
 	m.mu.RUnlock()
 
 	if !exists {
@@ -285,5 +368,16 @@ func (m *Manager) SendToChannel(ctx context.Context, channelName, chatID, conten
 		Content: content,
 	}
 
+	if wExists {
+		select {
+		case w.queue <- msg:
+			return nil
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	// Fallback: direct send (should not happen)
+	channel, _ := m.channels[channelName]
 	return channel.Send(ctx, msg)
 }
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index b459a7140..fc0bee505 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -50,7 +50,7 @@ func NewSlackChannel(cfg config.SlackConfig, messageBus *bus.MessageBus) (*Slack
 
 	socketClient := socketmode.New(api)
 
-	base := channels.NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(40000))
 
 	return &SlackChannel{
 		BaseChannel:  base,
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index af825ddc9..578e3c51e 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -76,7 +76,13 @@ func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChann
 		return nil, fmt.Errorf("failed to create telegram bot: %w", err)
 	}
 
-	base := channels.NewBaseChannel("telegram", telegramCfg, bus, telegramCfg.AllowFrom)
+	base := channels.NewBaseChannel(
+		"telegram",
+		telegramCfg,
+		bus,
+		telegramCfg.AllowFrom,
+		channels.WithMaxMessageLength(4096),
+	)
 
 	return &TelegramChannel{
 		BaseChannel:  base,
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 873431d3c..eb1711d75 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -120,7 +120,7 @@ func NewWeComAppChannel(cfg config.WeComAppConfig, messageBus *bus.MessageBus) (
 		return nil, fmt.Errorf("wecom_app corp_id, corp_secret and agent_id are required")
 	}
 
-	base := channels.NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(2048))
 
 	return &WeComAppChannel{
 		BaseChannel:   base,
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 3a8a16c43..bbac8611a 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -87,7 +87,7 @@ func NewWeComBotChannel(cfg config.WeComConfig, messageBus *bus.MessageBus) (*We
 		return nil, fmt.Errorf("wecom token and webhook_url are required")
 	}
 
-	base := channels.NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(2048))
 
 	return &WeComBotChannel{
 		BaseChannel:   base,
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index cbc82fd09..b5f3e99d7 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -28,7 +28,7 @@ type WhatsAppChannel struct {
 }
 
 func NewWhatsAppChannel(cfg config.WhatsAppConfig, bus *bus.MessageBus) (*WhatsAppChannel, error) {
-	base := channels.NewBaseChannel("whatsapp", cfg, bus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("whatsapp", cfg, bus, cfg.AllowFrom, channels.WithMaxMessageLength(65536))
 
 	return &WhatsAppChannel{
 		BaseChannel: base,
diff --git a/pkg/utils/message.go b/pkg/utils/message.go
index 1d05950d9..52a967f4c 100644
--- a/pkg/utils/message.go
+++ b/pkg/utils/message.go
@@ -5,11 +5,20 @@ import (
 )
 
 // SplitMessage splits long messages into chunks, preserving code block integrity.
+// The maxLen parameter is measured in runes (Unicode characters), not bytes.
 // The function reserves a buffer (10% of maxLen, min 50) to leave room for closing code blocks,
 // but may extend to maxLen when needed.
 // Call SplitMessage with the full text content and the maximum allowed length of a single message;
 // it returns a slice of message chunks that each respect maxLen and avoid splitting fenced code blocks.
 func SplitMessage(content string, maxLen int) []string {
+	if maxLen <= 0 {
+		if content == "" {
+			return nil
+		}
+		return []string{content}
+	}
+
+	runes := []rune(content)
 	var messages []string
 
 	// Dynamic buffer: 10% of maxLen, but at least 50 chars if possible
@@ -21,9 +30,9 @@ func SplitMessage(content string, maxLen int) []string {
 		codeBlockBuffer = maxLen / 2
 	}
 
-	for len(content) > 0 {
-		if len(content) <= maxLen {
-			messages = append(messages, content)
+	for len(runes) > 0 {
+		if len(runes) <= maxLen {
+			messages = append(messages, string(runes))
 			break
 		}
 
@@ -34,56 +43,66 @@ func SplitMessage(content string, maxLen int) []string {
 		}
 
 		// Find natural split point within the effective limit
-		msgEnd := findLastNewline(content[:effectiveLimit], 200)
+		msgEnd := findLastNewlineRunes(runes[:effectiveLimit], 200)
 		if msgEnd <= 0 {
-			msgEnd = findLastSpace(content[:effectiveLimit], 100)
+			msgEnd = findLastSpaceRunes(runes[:effectiveLimit], 100)
 		}
 		if msgEnd <= 0 {
 			msgEnd = effectiveLimit
 		}
 
 		// Check if this would end with an incomplete code block
-		candidate := content[:msgEnd]
-		unclosedIdx := findLastUnclosedCodeBlock(candidate)
+		candidate := runes[:msgEnd]
+		unclosedIdx := findLastUnclosedCodeBlockRunes(candidate)
 
 		if unclosedIdx >= 0 {
 			// Message would end with incomplete code block
 			// Try to extend up to maxLen to include the closing ```
-			if len(content) > msgEnd {
-				closingIdx := findNextClosingCodeBlock(content, msgEnd)
+			if len(runes) > msgEnd {
+				closingIdx := findNextClosingCodeBlockRunes(runes, msgEnd)
 				if closingIdx > 0 && closingIdx <= maxLen {
 					// Extend to include the closing ```
 					msgEnd = closingIdx
 				} else {
 					// Code block is too long to fit in one chunk or missing closing fence.
 					// Try to split inside by injecting closing and reopening fences.
-					headerEnd := strings.Index(content[unclosedIdx:], "\n")
+					candidateStr := string(candidate)
+					unclosedStr := string(runes[unclosedIdx:])
+					headerEnd := strings.Index(unclosedStr, "\n")
+					var header string
 					if headerEnd == -1 {
-						headerEnd = unclosedIdx + 3
+						header = strings.TrimSpace(string(runes[unclosedIdx : unclosedIdx+3]))
 					} else {
-						headerEnd += unclosedIdx
+						header = strings.TrimSpace(string(runes[unclosedIdx : unclosedIdx+headerEnd]))
 					}
-					header := strings.TrimSpace(content[unclosedIdx:headerEnd])
+					headerEndIdx := unclosedIdx + len([]rune(header))
+					if headerEnd != -1 {
+						headerEndIdx = unclosedIdx + headerEnd
+					}
+
+					_ = candidateStr // used above for context
 
 					// If we have a reasonable amount of content after the header, split inside
-					if msgEnd > headerEnd+20 {
+					if msgEnd > headerEndIdx+20 {
 						// Find a better split point closer to maxLen
 						innerLimit := maxLen - 5 // Leave room for "\n```"
-						betterEnd := findLastNewline(content[:innerLimit], 200)
-						if betterEnd > headerEnd {
+						betterEnd := findLastNewlineRunes(runes[:innerLimit], 200)
+						if betterEnd > headerEndIdx {
 							msgEnd = betterEnd
 						} else {
 							msgEnd = innerLimit
 						}
-						messages = append(messages, strings.TrimRight(content[:msgEnd], " \t\n\r")+"\n```")
-						content = strings.TrimSpace(header + "\n" + content[msgEnd:])
+						chunk := strings.TrimRight(string(runes[:msgEnd]), " \t\n\r") + "\n```"
+						messages = append(messages, chunk)
+						remaining := strings.TrimSpace(header + "\n" + string(runes[msgEnd:]))
+						runes = []rune(remaining)
 						continue
 					}
 
 					// Otherwise, try to split before the code block starts
-					newEnd := findLastNewline(content[:unclosedIdx], 200)
+					newEnd := findLastNewlineRunes(runes[:unclosedIdx], 200)
 					if newEnd <= 0 {
-						newEnd = findLastSpace(content[:unclosedIdx], 100)
+						newEnd = findLastSpaceRunes(runes[:unclosedIdx], 100)
 					}
 					if newEnd > 0 {
 						msgEnd = newEnd
@@ -93,8 +112,10 @@ func SplitMessage(content string, maxLen int) []string {
 							msgEnd = unclosedIdx
 						} else {
 							msgEnd = maxLen - 5
-							messages = append(messages, strings.TrimRight(content[:msgEnd], " \t\n\r")+"\n```")
-							content = strings.TrimSpace(header + "\n" + content[msgEnd:])
+							chunk := strings.TrimRight(string(runes[:msgEnd]), " \t\n\r") + "\n```"
+							messages = append(messages, chunk)
+							remaining := strings.TrimSpace(header + "\n" + string(runes[msgEnd:]))
+							runes = []rune(remaining)
 							continue
 						}
 					}
@@ -106,21 +127,22 @@ func SplitMessage(content string, maxLen int) []string {
 			msgEnd = effectiveLimit
 		}
 
-		messages = append(messages, content[:msgEnd])
-		content = strings.TrimSpace(content[msgEnd:])
+		messages = append(messages, string(runes[:msgEnd]))
+		remaining := strings.TrimSpace(string(runes[msgEnd:]))
+		runes = []rune(remaining)
 	}
 
 	return messages
 }
 
-// findLastUnclosedCodeBlock finds the last opening ``` that doesn't have a closing ```
-// Returns the position of the opening ``` or -1 if all code blocks are complete
-func findLastUnclosedCodeBlock(text string) int {
+// findLastUnclosedCodeBlockRunes finds the last opening ``` that doesn't have a closing ```
+// Returns the rune position of the opening ``` or -1 if all code blocks are complete
+func findLastUnclosedCodeBlockRunes(runes []rune) int {
 	inCodeBlock := false
 	lastOpenIdx := -1
 
-	for i := 0; i < len(text); i++ {
-		if i+2 < len(text) && text[i] == '`' && text[i+1] == '`' && text[i+2] == '`' {
+	for i := 0; i < len(runes); i++ {
+		if i+2 < len(runes) && runes[i] == '`' && runes[i+1] == '`' && runes[i+2] == '`' {
 			// Toggle code block state on each fence
 			if !inCodeBlock {
 				// Entering a code block: record this opening fence
@@ -137,41 +159,41 @@ func findLastUnclosedCodeBlock(text string) int {
 	return -1
 }
 
-// findNextClosingCodeBlock finds the next closing ``` starting from a position
-// Returns the position after the closing ``` or -1 if not found
-func findNextClosingCodeBlock(text string, startIdx int) int {
-	for i := startIdx; i < len(text); i++ {
-		if i+2 < len(text) && text[i] == '`' && text[i+1] == '`' && text[i+2] == '`' {
+// findNextClosingCodeBlockRunes finds the next closing ``` starting from a rune position
+// Returns the rune position after the closing ``` or -1 if not found
+func findNextClosingCodeBlockRunes(runes []rune, startIdx int) int {
+	for i := startIdx; i < len(runes); i++ {
+		if i+2 < len(runes) && runes[i] == '`' && runes[i+1] == '`' && runes[i+2] == '`' {
 			return i + 3
 		}
 	}
 	return -1
 }
 
-// findLastNewline finds the last newline character within the last N characters
-// Returns the position of the newline or -1 if not found
-func findLastNewline(s string, searchWindow int) int {
-	searchStart := len(s) - searchWindow
+// findLastNewlineRunes finds the last newline character within the last N runes
+// Returns the rune position of the newline or -1 if not found
+func findLastNewlineRunes(runes []rune, searchWindow int) int {
+	searchStart := len(runes) - searchWindow
 	if searchStart < 0 {
 		searchStart = 0
 	}
-	for i := len(s) - 1; i >= searchStart; i-- {
-		if s[i] == '\n' {
+	for i := len(runes) - 1; i >= searchStart; i-- {
+		if runes[i] == '\n' {
 			return i
 		}
 	}
 	return -1
 }
 
-// findLastSpace finds the last space character within the last N characters
-// Returns the position of the space or -1 if not found
-func findLastSpace(s string, searchWindow int) int {
-	searchStart := len(s) - searchWindow
+// findLastSpaceRunes finds the last space character within the last N runes
+// Returns the rune position of the space or -1 if not found
+func findLastSpaceRunes(runes []rune, searchWindow int) int {
+	searchStart := len(runes) - searchWindow
 	if searchStart < 0 {
 		searchStart = 0
 	}
-	for i := len(s) - 1; i >= searchStart; i-- {
-		if s[i] == ' ' || s[i] == '\t' {
+	for i := len(runes) - 1; i >= searchStart; i-- {
+		if runes[i] == ' ' || runes[i] == '\t' {
 			return i
 		}
 	}
diff --git a/pkg/utils/message_test.go b/pkg/utils/message_test.go
index 338509437..78e1e2b40 100644
--- a/pkg/utils/message_test.go
+++ b/pkg/utils/message_test.go
@@ -34,11 +34,15 @@ func TestSplitMessage(t *testing.T) {
 			maxLen:       2000,
 			expectChunks: 2,
 			checkContent: func(t *testing.T, chunks []string) {
-				if len(chunks[0]) > 2000 {
-					t.Errorf("Chunk 0 too large: %d", len(chunks[0]))
+				if len([]rune(chunks[0])) > 2000 {
+					t.Errorf("Chunk 0 too large: %d runes", len([]rune(chunks[0])))
 				}
-				if len(chunks[0])+len(chunks[1]) != len(longText) {
-					t.Errorf("Total length mismatch. Got %d, want %d", len(chunks[0])+len(chunks[1]), len(longText))
+				if len([]rune(chunks[0]))+len([]rune(chunks[1])) != len([]rune(longText)) {
+					t.Errorf(
+						"Total rune length mismatch. Got %d, want %d",
+						len([]rune(chunks[0]))+len([]rune(chunks[1])),
+						len([]rune(longText)),
+					)
 				}
 			},
 		},
@@ -53,11 +57,11 @@ func TestSplitMessage(t *testing.T) {
 			maxLen:       2000,
 			expectChunks: 2,
 			checkContent: func(t *testing.T, chunks []string) {
-				if len(chunks[0]) != 1750 {
-					t.Errorf("Expected chunk 0 to be 1750 length (split at newline), got %d", len(chunks[0]))
+				if len([]rune(chunks[0])) != 1750 {
+					t.Errorf("Expected chunk 0 to be 1750 runes (split at newline), got %d", len([]rune(chunks[0])))
 				}
 				if chunks[1] != strings.Repeat("b", 300) {
-					t.Errorf("Chunk 1 content mismatch. Len: %d", len(chunks[1]))
+					t.Errorf("Chunk 1 content mismatch. Len: %d", len([]rune(chunks[1])))
 				}
 			},
 		},
@@ -78,17 +82,39 @@ func TestSplitMessage(t *testing.T) {
 			},
 		},
 		{
-			name:         "Preserve Unicode characters",
-			content:      strings.Repeat("\u4e16", 1000), // 3000 bytes
+			name:         "Preserve Unicode characters (rune-aware)",
+			content:      strings.Repeat("\u4e16", 2500), // 2500 runes, 7500 bytes
 			maxLen:       2000,
 			expectChunks: 2,
 			checkContent: func(t *testing.T, chunks []string) {
-				// Just verify we didn't panic and got valid strings.
-				// Go strings are UTF-8, if we split mid-rune it would be bad,
-				// but standard slicing might do that.
-				// Let's assume standard behavior is acceptable or check if it produces invalid rune?
-				if !strings.Contains(chunks[0], "\u4e16") {
-					t.Error("Chunk should contain unicode characters")
+				// Verify chunks contain valid unicode and don't split mid-rune
+				for i, chunk := range chunks {
+					runeCount := len([]rune(chunk))
+					if runeCount > 2000 {
+						t.Errorf("Chunk %d has %d runes, exceeds maxLen 2000", i, runeCount)
+					}
+					if !strings.Contains(chunk, "\u4e16") {
+						t.Errorf("Chunk %d should contain unicode characters", i)
+					}
+				}
+				// Verify total rune count is preserved
+				totalRunes := 0
+				for _, chunk := range chunks {
+					totalRunes += len([]rune(chunk))
+				}
+				if totalRunes != 2500 {
+					t.Errorf("Total rune count mismatch. Got %d, want 2500", totalRunes)
+				}
+			},
+		},
+		{
+			name:         "Zero maxLen returns single chunk",
+			content:      "Hello world",
+			maxLen:       0,
+			expectChunks: 1,
+			checkContent: func(t *testing.T, chunks []string) {
+				if chunks[0] != "Hello world" {
+					t.Errorf("Expected original content, got %q", chunks[0])
 				}
 			},
 		},
@@ -145,7 +171,7 @@ func TestSplitMessage_CodeBlockIntegrity(t *testing.T) {
 	}
 
 	// First chunk should contain meaningful content
-	if len(chunks[0]) > 40 {
-		t.Errorf("First chunk exceeded maxLen: length %d", len(chunks[0]))
+	if len([]rune(chunks[0])) > 40 {
+		t.Errorf("First chunk exceeded maxLen: length %d runes", len([]rune(chunks[0])))
 	}
 }

From 8116bcb6bc7ae7cb8215d95708efc59b34505248 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sun, 22 Feb 2026 23:27:55 +0800
Subject: [PATCH 37/52] refactor(media): add MediaStore for unified media file
 lifecycle management

Channels previously deleted downloaded media files via defer os.Remove,
racing with the async Agent consumer. Introduce MediaStore to decouple
file ownership: channels register files on download, Agent releases them
after processing via ReleaseAll(scope).

- New pkg/media with MediaStore interface + FileMediaStore implementation
- InboundMessage gains MediaScope field for lifecycle tracking
- BaseChannel gains SetMediaStore/GetMediaStore + BuildMediaScope helper
- Manager injects MediaStore into channels; AgentLoop releases on completion
- Telegram, Discord, Slack, OneBot, LINE channels migrated from defer
  os.Remove to store.Store() with media:// refs
---
 cmd/picoclaw/cmd_gateway.go       |   9 +-
 pkg/agent/loop.go                 |  65 +++++++----
 pkg/bus/types.go                  |   5 +-
 pkg/channels/base.go              |  38 +++++--
 pkg/channels/discord/discord.go   |  28 ++---
 pkg/channels/line/line.go         |  33 +++---
 pkg/channels/manager.go           |  19 +++-
 pkg/channels/onebot/onebot.go     |  66 ++++++-----
 pkg/channels/slack/slack.go       |  28 ++---
 pkg/channels/telegram/telegram.go |  39 +++----
 pkg/media/store.go                | 102 +++++++++++++++++
 pkg/media/store_test.go           | 179 ++++++++++++++++++++++++++++++
 12 files changed, 484 insertions(+), 127 deletions(-)
 create mode 100644 pkg/media/store.go
 create mode 100644 pkg/media/store_test.go

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index c62c868e3..3c2cb021d 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -33,6 +33,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/health"
 	"github.com/sipeed/picoclaw/pkg/heartbeat"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/providers"
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
@@ -123,14 +124,18 @@ func gatewayCmd() {
 		return tools.SilentResult(response)
 	})
 
-	channelManager, err := channels.NewManager(cfg, msgBus)
+	// Create media store for file lifecycle management
+	mediaStore := media.NewFileMediaStore()
+
+	channelManager, err := channels.NewManager(cfg, msgBus, mediaStore)
 	if err != nil {
 		fmt.Printf("Error creating channel manager: %v\n", err)
 		os.Exit(1)
 	}
 
-	// Inject channel manager into agent loop for command handling
+	// Inject channel manager and media store into agent loop
 	agentLoop.SetChannelManager(channelManager)
+	agentLoop.SetMediaStore(mediaStore)
 
 	var transcriber *voice.GroqTranscriber
 	groqAPIKey := cfg.Providers.Groq.APIKey
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index d8ea3b091..97569bef7 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -21,6 +21,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/constants"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/providers"
 	"github.com/sipeed/picoclaw/pkg/routing"
 	"github.com/sipeed/picoclaw/pkg/skills"
@@ -38,6 +39,7 @@ type AgentLoop struct {
 	summarizing    sync.Map
 	fallback       *providers.FallbackChain
 	channelManager *channels.Manager
+	mediaStore     media.MediaStore
 }
 
 // processOptions configures how a message is processed
@@ -167,33 +169,47 @@ func (al *AgentLoop) Run(ctx context.Context) error {
 				continue
 			}
 
-			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()
+			// Process message and ensure media is released afterward
+			func() {
+				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 !alreadySent {
-					al.bus.PublishOutbound(bus.OutboundMessage{
-						Channel: msg.Channel,
-						ChatID:  msg.ChatID,
-						Content: response,
-					})
+				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(bus.OutboundMessage{
+							Channel: msg.Channel,
+							ChatID:  msg.ChatID,
+							Content: response,
+						})
+					}
 				}
-			}
+			}()
 		}
 	}
 
@@ -216,6 +232,11 @@ 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
+}
+
 // 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 {
diff --git a/pkg/bus/types.go b/pkg/bus/types.go
index 081f13a0b..e49713eb8 100644
--- a/pkg/bus/types.go
+++ b/pkg/bus/types.go
@@ -12,8 +12,9 @@ type InboundMessage struct {
 	ChatID     string            `json:"chat_id"`
 	Content    string            `json:"content"`
 	Media      []string          `json:"media,omitempty"`
-	Peer       Peer              `json:"peer"`                 // routing peer
-	MessageID  string            `json:"message_id,omitempty"` // platform message ID
+	Peer       Peer              `json:"peer"`                  // routing peer
+	MessageID  string            `json:"message_id,omitempty"`  // platform message ID
+	MediaScope string            `json:"media_scope,omitempty"` // media lifecycle scope
 	SessionKey string            `json:"session_key"`
 	Metadata   map[string]string `json:"metadata,omitempty"`
 }
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index f70145981..d967d9e91 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -5,7 +5,10 @@ import (
 	"strings"
 	"sync/atomic"
 
+	"github.com/google/uuid"
+
 	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/media"
 )
 
 type Channel interface {
@@ -41,6 +44,7 @@ type BaseChannel struct {
 	name             string
 	allowList        []string
 	maxMessageLength int
+	mediaStore       media.MediaStore
 }
 
 func NewBaseChannel(
@@ -125,15 +129,18 @@ func (c *BaseChannel) HandleMessage(
 		return
 	}
 
+	scope := BuildMediaScope(c.name, chatID, messageID)
+
 	msg := bus.InboundMessage{
-		Channel:   c.name,
-		SenderID:  senderID,
-		ChatID:    chatID,
-		Content:   content,
-		Media:     media,
-		Peer:      peer,
-		MessageID: messageID,
-		Metadata:  metadata,
+		Channel:    c.name,
+		SenderID:   senderID,
+		ChatID:     chatID,
+		Content:    content,
+		Media:      media,
+		Peer:       peer,
+		MessageID:  messageID,
+		MediaScope: scope,
+		Metadata:   metadata,
 	}
 
 	c.bus.PublishInbound(msg)
@@ -142,3 +149,18 @@ func (c *BaseChannel) HandleMessage(
 func (c *BaseChannel) SetRunning(running bool) {
 	c.running.Store(running)
 }
+
+// SetMediaStore injects a MediaStore into the channel.
+func (c *BaseChannel) SetMediaStore(s media.MediaStore) { c.mediaStore = s }
+
+// GetMediaStore returns the injected MediaStore (may be nil).
+func (c *BaseChannel) GetMediaStore() media.MediaStore { return c.mediaStore }
+
+// BuildMediaScope constructs a scope key for media lifecycle tracking.
+func BuildMediaScope(channel, chatID, messageID string) string {
+	id := messageID
+	if id == "" {
+		id = uuid.New().String()
+	}
+	return channel + ":" + chatID + ":" + id
+}
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 623bc9f48..7977d32e1 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -3,7 +3,6 @@ package discord
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"
 	"sync"
 	"time"
@@ -14,6 +13,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 	"github.com/sipeed/picoclaw/pkg/voice"
 )
@@ -202,19 +202,22 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 	content := m.Content
 	content = c.stripBotMention(content)
 	mediaPaths := make([]string, 0, len(m.Attachments))
-	localFiles := make([]string, 0, len(m.Attachments))
 
-	// Ensure temp files are cleaned up when function returns
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("discord", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
+	scope := channels.BuildMediaScope("discord", m.ChannelID, m.ID)
+
+	// Helper to register a local file with the media store
+	storeMedia := func(localPath, filename string) string {
+		if store := c.GetMediaStore(); store != nil {
+			ref, err := store.Store(localPath, media.MediaMeta{
+				Filename: filename,
+				Source:   "discord",
+			}, scope)
+			if err == nil {
+				return ref
 			}
 		}
-	}()
+		return localPath // fallback
+	}
 
 	for _, attachment := range m.Attachments {
 		isAudio := utils.IsAudioFile(attachment.Filename, attachment.ContentType)
@@ -222,8 +225,6 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		if isAudio {
 			localPath := c.downloadAttachment(attachment.URL, attachment.Filename)
 			if localPath != "" {
-				localFiles = append(localFiles, localPath)
-
 				transcribedText := ""
 				if c.transcriber != nil && c.transcriber.IsAvailable() {
 					ctx, cancel := context.WithTimeout(c.ctx, transcriptionTimeout)
@@ -245,6 +246,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 					transcribedText = fmt.Sprintf("[audio: %s]", attachment.Filename)
 				}
 
+				mediaPaths = append(mediaPaths, storeMedia(localPath, attachment.Filename))
 				content = appendContent(content, transcribedText)
 			} else {
 				logger.WarnCF("discord", "Failed to download audio attachment", map[string]any{
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 9744e1848..272a53c6e 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"strings"
 	"sync"
 	"time"
@@ -19,6 +18,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
@@ -308,18 +308,22 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 
 	var content string
 	var mediaPaths []string
-	localFiles := []string{}
 
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("line", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
+	scope := channels.BuildMediaScope("line", chatID, msg.ID)
+
+	// Helper to register a local file with the media store
+	storeMedia := func(localPath, filename string) string {
+		if store := c.GetMediaStore(); store != nil {
+			ref, err := store.Store(localPath, media.MediaMeta{
+				Filename: filename,
+				Source:   "line",
+			}, scope)
+			if err == nil {
+				return ref
 			}
 		}
-	}()
+		return localPath // fallback
+	}
 
 	switch msg.Type {
 	case "text":
@@ -331,22 +335,19 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	case "image":
 		localPath := c.downloadContent(msg.ID, "image.jpg")
 		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
+			mediaPaths = append(mediaPaths, storeMedia(localPath, "image.jpg"))
 			content = "[image]"
 		}
 	case "audio":
 		localPath := c.downloadContent(msg.ID, "audio.m4a")
 		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
+			mediaPaths = append(mediaPaths, storeMedia(localPath, "audio.m4a"))
 			content = "[audio]"
 		}
 	case "video":
 		localPath := c.downloadContent(msg.ID, "video.mp4")
 		if localPath != "" {
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
+			mediaPaths = append(mediaPaths, storeMedia(localPath, "video.mp4"))
 			content = "[video]"
 		}
 	case "file":
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 081d616da..37af01796 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -15,6 +15,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/constants"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
@@ -31,6 +32,7 @@ type Manager struct {
 	workers      map[string]*channelWorker
 	bus          *bus.MessageBus
 	config       *config.Config
+	mediaStore   media.MediaStore
 	dispatchTask *asyncTask
 	mu           sync.RWMutex
 }
@@ -39,12 +41,13 @@ type asyncTask struct {
 	cancel context.CancelFunc
 }
 
-func NewManager(cfg *config.Config, messageBus *bus.MessageBus) (*Manager, error) {
+func NewManager(cfg *config.Config, messageBus *bus.MessageBus, store media.MediaStore) (*Manager, error) {
 	m := &Manager{
-		channels: make(map[string]Channel),
-		workers:  make(map[string]*channelWorker),
-		bus:      messageBus,
-		config:   cfg,
+		channels:   make(map[string]Channel),
+		workers:    make(map[string]*channelWorker),
+		bus:        messageBus,
+		config:     cfg,
+		mediaStore: store,
 	}
 
 	if err := m.initChannels(); err != nil {
@@ -73,6 +76,12 @@ func (m *Manager) initChannel(name, displayName string) {
 			"error":   err.Error(),
 		})
 	} else {
+		// Inject MediaStore if channel supports it
+		if m.mediaStore != nil {
+			if setter, ok := ch.(interface{ SetMediaStore(s media.MediaStore) }); ok {
+				setter.SetMediaStore(m.mediaStore)
+			}
+		}
 		m.channels[name] = ch
 		m.workers[name] = &channelWorker{
 			ch:    ch,
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 4f35888ca..e2fe541f1 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -17,6 +16,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 	"github.com/sipeed/picoclaw/pkg/voice"
 )
@@ -575,11 +575,15 @@ type parseMessageResult struct {
 	Text           string
 	IsBotMentioned bool
 	Media          []string
-	LocalFiles     []string
 	ReplyTo        string
 }
 
-func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64) parseMessageResult {
+func (c *OneBotChannel) parseMessageSegments(
+	raw json.RawMessage,
+	selfID int64,
+	store media.MediaStore,
+	scope string,
+) parseMessageResult {
 	if len(raw) == 0 {
 		return parseMessageResult{}
 	}
@@ -606,10 +610,23 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 	var textParts []string
 	mentioned := false
 	selfIDStr := strconv.FormatInt(selfID, 10)
-	var media []string
-	var localFiles []string
+	var mediaRefs []string
 	var replyTo string
 
+	// Helper to register a local file with the media store
+	storeFile := func(localPath, filename string) string {
+		if store != nil {
+			ref, err := store.Store(localPath, media.MediaMeta{
+				Filename: filename,
+				Source:   "onebot",
+			}, scope)
+			if err == nil {
+				return ref
+			}
+		}
+		return localPath // fallback
+	}
+
 	for _, seg := range segments {
 		segType, _ := seg["type"].(string)
 		data, _ := seg["data"].(map[string]any)
@@ -645,8 +662,7 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 						LoggerPrefix: "onebot",
 					})
 					if localPath != "" {
-						media = append(media, localPath)
-						localFiles = append(localFiles, localPath)
+						mediaRefs = append(mediaRefs, storeFile(localPath, filename))
 						textParts = append(textParts, fmt.Sprintf("[%s]", segType))
 					}
 				}
@@ -660,7 +676,6 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 						LoggerPrefix: "onebot",
 					})
 					if localPath != "" {
-						localFiles = append(localFiles, localPath)
 						if c.transcriber != nil && c.transcriber.IsAvailable() {
 							tctx, tcancel := context.WithTimeout(c.ctx, 30*time.Second)
 							result, err := c.transcriber.Transcribe(tctx, localPath)
@@ -670,13 +685,15 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 									"error": err.Error(),
 								})
 								textParts = append(textParts, "[voice (transcription failed)]")
-								media = append(media, localPath)
+								mediaRefs = append(mediaRefs, storeFile(localPath, "voice.amr"))
 							} else {
 								textParts = append(textParts, fmt.Sprintf("[voice transcription: %s]", result.Text))
+								// Still store the file so it can be released later
+								storeFile(localPath, "voice.amr")
 							}
 						} else {
 							textParts = append(textParts, "[voice]")
-							media = append(media, localPath)
+							mediaRefs = append(mediaRefs, storeFile(localPath, "voice.amr"))
 						}
 					}
 				}
@@ -706,8 +723,7 @@ func (c *OneBotChannel) parseMessageSegments(raw json.RawMessage, selfID int64)
 	return parseMessageResult{
 		Text:           strings.TrimSpace(strings.Join(textParts, "")),
 		IsBotMentioned: mentioned,
-		Media:          media,
-		LocalFiles:     localFiles,
+		Media:          mediaRefs,
 		ReplyTo:        replyTo,
 	}
 }
@@ -799,7 +815,17 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		selfID = atomic.LoadInt64(&c.selfID)
 	}
 
-	parsed := c.parseMessageSegments(raw.Message, selfID)
+	// Compute scope for media store before parsing (parsing may download files)
+	var chatIDForScope string
+	switch raw.MessageType {
+	case "group":
+		chatIDForScope = "group:" + strconv.FormatInt(groupID, 10)
+	default:
+		chatIDForScope = "private:" + strconv.FormatInt(userID, 10)
+	}
+	scope := channels.BuildMediaScope("onebot", chatIDForScope, messageID)
+
+	parsed := c.parseMessageSegments(raw.Message, selfID, c.GetMediaStore(), scope)
 	isBotMentioned := parsed.IsBotMentioned
 
 	content := raw.RawMessage
@@ -828,20 +854,6 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		}
 	}
 
-	// Clean up temp files when done
-	if len(parsed.LocalFiles) > 0 {
-		defer func() {
-			for _, f := range parsed.LocalFiles {
-				if err := os.Remove(f); err != nil {
-					logger.DebugCF("onebot", "Failed to remove temp file", map[string]any{
-						"path":  f,
-						"error": err.Error(),
-					})
-				}
-			}
-		}()
-	}
-
 	if c.isDuplicate(messageID) {
 		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]any{
 			"message_id": messageID,
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index fc0bee505..53d7c0609 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -3,7 +3,6 @@ package slack
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"
 	"sync"
 	"time"
@@ -16,6 +15,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 	"github.com/sipeed/picoclaw/pkg/voice"
 )
@@ -233,19 +233,22 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 	content = c.stripBotMention(content)
 
 	var mediaPaths []string
-	localFiles := []string{} // 跟踪需要清理的本地文件
 
-	// 确保临时文件在函数返回时被清理
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("slack", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
+	scope := channels.BuildMediaScope("slack", chatID, messageTS)
+
+	// Helper to register a local file with the media store
+	storeMedia := func(localPath, filename string) string {
+		if store := c.GetMediaStore(); store != nil {
+			ref, err := store.Store(localPath, media.MediaMeta{
+				Filename: filename,
+				Source:   "slack",
+			}, scope)
+			if err == nil {
+				return ref
 			}
 		}
-	}()
+		return localPath // fallback
+	}
 
 	if ev.Message != nil && len(ev.Message.Files) > 0 {
 		for _, file := range ev.Message.Files {
@@ -253,8 +256,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 			if localPath == "" {
 				continue
 			}
-			localFiles = append(localFiles, localPath)
-			mediaPaths = append(mediaPaths, localPath)
+			mediaPaths = append(mediaPaths, storeMedia(localPath, file.Name))
 
 			if utils.IsAudioFile(file.Name, file.Mimetype) && c.transcriber != nil && c.transcriber.IsAvailable() {
 				ctx, cancel := context.WithTimeout(c.ctx, 30*time.Second)
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 578e3c51e..af7155799 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -20,6 +20,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
 	"github.com/sipeed/picoclaw/pkg/voice"
 )
@@ -251,19 +252,24 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 
 	content := ""
 	mediaPaths := []string{}
-	localFiles := []string{} // 跟踪需要清理的本地文件
 
-	// 确保临时文件在函数返回时被清理
-	defer func() {
-		for _, file := range localFiles {
-			if err := os.Remove(file); err != nil {
-				logger.DebugCF("telegram", "Failed to cleanup temp file", map[string]any{
-					"file":  file,
-					"error": err.Error(),
-				})
+	chatIDStr := fmt.Sprintf("%d", chatID)
+	messageIDStr := fmt.Sprintf("%d", message.MessageID)
+	scope := channels.BuildMediaScope("telegram", chatIDStr, messageIDStr)
+
+	// Helper to register a local file with the media store
+	storeMedia := func(localPath, filename string) string {
+		if store := c.GetMediaStore(); store != nil {
+			ref, err := store.Store(localPath, media.MediaMeta{
+				Filename: filename,
+				Source:   "telegram",
+			}, scope)
+			if err == nil {
+				return ref
 			}
 		}
-	}()
+		return localPath // fallback: use raw path
+	}
 
 	if message.Text != "" {
 		content += message.Text
@@ -280,8 +286,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		photo := message.Photo[len(message.Photo)-1]
 		photoPath := c.downloadPhoto(ctx, photo.FileID)
 		if photoPath != "" {
-			localFiles = append(localFiles, photoPath)
-			mediaPaths = append(mediaPaths, photoPath)
+			mediaPaths = append(mediaPaths, storeMedia(photoPath, "photo.jpg"))
 			if content != "" {
 				content += "\n"
 			}
@@ -292,8 +297,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	if message.Voice != nil {
 		voicePath := c.downloadFile(ctx, message.Voice.FileID, ".ogg")
 		if voicePath != "" {
-			localFiles = append(localFiles, voicePath)
-			mediaPaths = append(mediaPaths, voicePath)
+			mediaPaths = append(mediaPaths, storeMedia(voicePath, "voice.ogg"))
 
 			transcribedText := ""
 			if c.transcriber != nil && c.transcriber.IsAvailable() {
@@ -327,8 +331,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	if message.Audio != nil {
 		audioPath := c.downloadFile(ctx, message.Audio.FileID, ".mp3")
 		if audioPath != "" {
-			localFiles = append(localFiles, audioPath)
-			mediaPaths = append(mediaPaths, audioPath)
+			mediaPaths = append(mediaPaths, storeMedia(audioPath, "audio.mp3"))
 			if content != "" {
 				content += "\n"
 			}
@@ -339,8 +342,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	if message.Document != nil {
 		docPath := c.downloadFile(ctx, message.Document.FileID, "")
 		if docPath != "" {
-			localFiles = append(localFiles, docPath)
-			mediaPaths = append(mediaPaths, docPath)
+			mediaPaths = append(mediaPaths, storeMedia(docPath, "document"))
 			if content != "" {
 				content += "\n"
 			}
@@ -367,7 +369,6 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	}
 
 	// Stop any previous thinking animation
-	chatIDStr := fmt.Sprintf("%d", chatID)
 	if prevStop, ok := c.stopThinking.Load(chatIDStr); ok {
 		if cf, ok := prevStop.(*thinkingCancel); ok && cf != nil {
 			cf.Cancel()
diff --git a/pkg/media/store.go b/pkg/media/store.go
new file mode 100644
index 000000000..8d03c03ef
--- /dev/null
+++ b/pkg/media/store.go
@@ -0,0 +1,102 @@
+package media
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"github.com/google/uuid"
+)
+
+// MediaMeta holds metadata about a stored media file.
+type MediaMeta struct {
+	Filename    string
+	ContentType string
+	Source      string // "telegram", "discord", "tool:image-gen", etc.
+}
+
+// MediaStore manages the lifecycle of media files associated with processing scopes.
+type MediaStore interface {
+	// Store registers an existing local file under the given scope.
+	// Returns a ref identifier (e.g. "media://<id>").
+	// Store does not move or copy the file; it only records the mapping.
+	Store(localPath string, meta MediaMeta, scope string) (ref string, err error)
+
+	// Resolve returns the local file path for a given ref.
+	Resolve(ref string) (localPath string, err error)
+
+	// ReleaseAll deletes all files registered under the given scope
+	// and removes the mapping entries. File-not-exist errors are ignored.
+	ReleaseAll(scope string) error
+}
+
+// FileMediaStore is a pure in-memory implementation of MediaStore.
+// Files are expected to already exist on disk (e.g. in /tmp/picoclaw_media/).
+type FileMediaStore struct {
+	mu          sync.RWMutex
+	refToPath   map[string]string
+	scopeToRefs map[string]map[string]struct{}
+}
+
+// NewFileMediaStore creates a new FileMediaStore.
+func NewFileMediaStore() *FileMediaStore {
+	return &FileMediaStore{
+		refToPath:   make(map[string]string),
+		scopeToRefs: make(map[string]map[string]struct{}),
+	}
+}
+
+// Store registers a local file under the given scope. The file must exist.
+func (s *FileMediaStore) Store(localPath string, meta MediaMeta, scope string) (string, error) {
+	if _, err := os.Stat(localPath); err != nil {
+		return "", fmt.Errorf("media store: file does not exist: %s", localPath)
+	}
+
+	ref := "media://" + uuid.New().String()[:8]
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.refToPath[ref] = localPath
+	if s.scopeToRefs[scope] == nil {
+		s.scopeToRefs[scope] = make(map[string]struct{})
+	}
+	s.scopeToRefs[scope][ref] = struct{}{}
+
+	return ref, nil
+}
+
+// Resolve returns the local path for the given ref.
+func (s *FileMediaStore) Resolve(ref string) (string, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	path, ok := s.refToPath[ref]
+	if !ok {
+		return "", fmt.Errorf("media store: unknown ref: %s", ref)
+	}
+	return path, nil
+}
+
+// ReleaseAll removes all files under the given scope and cleans up mappings.
+func (s *FileMediaStore) ReleaseAll(scope string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	refs, ok := s.scopeToRefs[scope]
+	if !ok {
+		return nil
+	}
+
+	for ref := range refs {
+		if path, exists := s.refToPath[ref]; exists {
+			if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+				// Log but continue — best effort cleanup
+			}
+			delete(s.refToPath, ref)
+		}
+	}
+
+	delete(s.scopeToRefs, scope)
+	return nil
+}
diff --git a/pkg/media/store_test.go b/pkg/media/store_test.go
new file mode 100644
index 000000000..361582307
--- /dev/null
+++ b/pkg/media/store_test.go
@@ -0,0 +1,179 @@
+package media
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func createTempFile(t *testing.T, dir, name string) string {
+	t.Helper()
+	path := filepath.Join(dir, name)
+	if err := os.WriteFile(path, []byte("test content"), 0o644); err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	return path
+}
+
+func TestStoreAndResolve(t *testing.T) {
+	dir := t.TempDir()
+	store := NewFileMediaStore()
+
+	path := createTempFile(t, dir, "photo.jpg")
+
+	ref, err := store.Store(path, MediaMeta{Filename: "photo.jpg", Source: "telegram"}, "scope1")
+	if err != nil {
+		t.Fatalf("Store failed: %v", err)
+	}
+
+	if !strings.HasPrefix(ref, "media://") {
+		t.Errorf("ref should start with media://, got %q", ref)
+	}
+
+	resolved, err := store.Resolve(ref)
+	if err != nil {
+		t.Fatalf("Resolve failed: %v", err)
+	}
+	if resolved != path {
+		t.Errorf("Resolve returned %q, want %q", resolved, path)
+	}
+}
+
+func TestReleaseAll(t *testing.T) {
+	dir := t.TempDir()
+	store := NewFileMediaStore()
+
+	paths := make([]string, 3)
+	refs := make([]string, 3)
+	for i := 0; i < 3; i++ {
+		paths[i] = createTempFile(t, dir, strings.Repeat("a", i+1)+".jpg")
+		var err error
+		refs[i], err = store.Store(paths[i], MediaMeta{Source: "test"}, "scope1")
+		if err != nil {
+			t.Fatalf("Store failed: %v", err)
+		}
+	}
+
+	if err := store.ReleaseAll("scope1"); err != nil {
+		t.Fatalf("ReleaseAll failed: %v", err)
+	}
+
+	// Files should be deleted
+	for _, p := range paths {
+		if _, err := os.Stat(p); !os.IsNotExist(err) {
+			t.Errorf("file %q should have been deleted", p)
+		}
+	}
+
+	// Refs should be unresolvable
+	for _, ref := range refs {
+		if _, err := store.Resolve(ref); err == nil {
+			t.Errorf("Resolve(%q) should fail after ReleaseAll", ref)
+		}
+	}
+}
+
+func TestMultiScopeIsolation(t *testing.T) {
+	dir := t.TempDir()
+	store := NewFileMediaStore()
+
+	pathA := createTempFile(t, dir, "fileA.jpg")
+	pathB := createTempFile(t, dir, "fileB.jpg")
+
+	refA, _ := store.Store(pathA, MediaMeta{Source: "test"}, "scopeA")
+	refB, _ := store.Store(pathB, MediaMeta{Source: "test"}, "scopeB")
+
+	// Release only scopeA
+	if err := store.ReleaseAll("scopeA"); err != nil {
+		t.Fatalf("ReleaseAll(scopeA) failed: %v", err)
+	}
+
+	// scopeA file should be gone
+	if _, err := os.Stat(pathA); !os.IsNotExist(err) {
+		t.Error("file A should have been deleted")
+	}
+	if _, err := store.Resolve(refA); err == nil {
+		t.Error("refA should be unresolvable after release")
+	}
+
+	// scopeB file should still exist
+	if _, err := os.Stat(pathB); err != nil {
+		t.Error("file B should still exist")
+	}
+	resolved, err := store.Resolve(refB)
+	if err != nil {
+		t.Fatalf("refB should still resolve: %v", err)
+	}
+	if resolved != pathB {
+		t.Errorf("resolved %q, want %q", resolved, pathB)
+	}
+}
+
+func TestReleaseAllIdempotent(t *testing.T) {
+	store := NewFileMediaStore()
+
+	// ReleaseAll on non-existent scope should not error
+	if err := store.ReleaseAll("nonexistent"); err != nil {
+		t.Fatalf("ReleaseAll on empty scope should not error: %v", err)
+	}
+
+	// Create and release, then release again
+	dir := t.TempDir()
+	path := createTempFile(t, dir, "file.jpg")
+	_, _ = store.Store(path, MediaMeta{Source: "test"}, "scope1")
+
+	if err := store.ReleaseAll("scope1"); err != nil {
+		t.Fatalf("first ReleaseAll failed: %v", err)
+	}
+	if err := store.ReleaseAll("scope1"); err != nil {
+		t.Fatalf("second ReleaseAll should not error: %v", err)
+	}
+}
+
+func TestStoreNonexistentFile(t *testing.T) {
+	store := NewFileMediaStore()
+
+	_, err := store.Store("/nonexistent/path/file.jpg", MediaMeta{Source: "test"}, "scope1")
+	if err == nil {
+		t.Error("Store should fail for nonexistent file")
+	}
+}
+
+func TestConcurrentSafety(t *testing.T) {
+	dir := t.TempDir()
+	store := NewFileMediaStore()
+
+	const goroutines = 20
+	const filesPerGoroutine = 5
+
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+
+	for g := 0; g < goroutines; g++ {
+		go func(gIdx int) {
+			defer wg.Done()
+			scope := strings.Repeat("s", gIdx+1)
+
+			for i := 0; i < filesPerGoroutine; i++ {
+				path := createTempFile(t, dir, strings.Repeat("f", gIdx*filesPerGoroutine+i+1)+".tmp")
+				ref, err := store.Store(path, MediaMeta{Source: "test"}, scope)
+				if err != nil {
+					t.Errorf("Store failed: %v", err)
+					return
+				}
+
+				if _, err := store.Resolve(ref); err != nil {
+					t.Errorf("Resolve failed: %v", err)
+				}
+			}
+
+			if err := store.ReleaseAll(scope); err != nil {
+				t.Errorf("ReleaseAll failed: %v", err)
+			}
+		}(g)
+	}
+
+	wg.Wait()
+}

From a32d98534c0d98a134cb5cb82fe0f1aae3377783 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Sun, 22 Feb 2026 23:51:55 +0800
Subject: [PATCH 38/52] refactor(channels): add per-channel rate limiting and
 send retry with error classification
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Define sentinel error types (ErrNotRunning, ErrRateLimit, ErrTemporary,
ErrSendFailed) so the Manager can classify Send failures and choose the
right retry strategy: permanent errors bail immediately, rate-limit
errors use a fixed 1s delay, and temporary/unknown errors use exponential
backoff (500ms→1s→2s, capped at 8s, up to 3 retries). A per-channel
token-bucket rate limiter (golang.org/x/time/rate) throttles outbound
sends before they hit the platform API.
---
 go.mod                       |   1 +
 go.sum                       |   2 +
 pkg/channels/errors.go       |  21 ++
 pkg/channels/errors_test.go  |  56 +++++
 pkg/channels/manager.go      | 127 +++++++++--
 pkg/channels/manager_test.go | 418 +++++++++++++++++++++++++++++++++++
 6 files changed, 601 insertions(+), 24 deletions(-)
 create mode 100644 pkg/channels/errors.go
 create mode 100644 pkg/channels/errors_test.go
 create mode 100644 pkg/channels/manager_test.go

diff --git a/go.mod b/go.mod
index 1f88639c8..32436ce53 100644
--- a/go.mod
+++ b/go.mod
@@ -23,6 +23,7 @@ require (
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/go.sum b/go.sum
index 0e95bf5cd..0e2d37cab 100644
--- a/go.sum
+++ b/go.sum
@@ -226,6 +226,8 @@ golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
 golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
diff --git a/pkg/channels/errors.go b/pkg/channels/errors.go
new file mode 100644
index 000000000..09ee88b3f
--- /dev/null
+++ b/pkg/channels/errors.go
@@ -0,0 +1,21 @@
+package channels
+
+import "errors"
+
+var (
+	// ErrNotRunning indicates the channel is not running.
+	// Manager will not retry.
+	ErrNotRunning = errors.New("channel not running")
+
+	// ErrRateLimit indicates the platform returned a rate-limit response (e.g. HTTP 429).
+	// Manager will wait a fixed delay and retry.
+	ErrRateLimit = errors.New("rate limited")
+
+	// ErrTemporary indicates a transient failure (e.g. network timeout, 5xx).
+	// Manager will use exponential backoff and retry.
+	ErrTemporary = errors.New("temporary failure")
+
+	// ErrSendFailed indicates a permanent failure (e.g. invalid chat ID, 4xx non-429).
+	// Manager will not retry.
+	ErrSendFailed = errors.New("send failed")
+)
diff --git a/pkg/channels/errors_test.go b/pkg/channels/errors_test.go
new file mode 100644
index 000000000..e5592345a
--- /dev/null
+++ b/pkg/channels/errors_test.go
@@ -0,0 +1,56 @@
+package channels
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestErrorsIs(t *testing.T) {
+	wrapped := fmt.Errorf("telegram API: %w", ErrRateLimit)
+	if !errors.Is(wrapped, ErrRateLimit) {
+		t.Error("wrapped ErrRateLimit should match")
+	}
+	if errors.Is(wrapped, ErrTemporary) {
+		t.Error("wrapped ErrRateLimit should not match ErrTemporary")
+	}
+}
+
+func TestErrorsIsAllTypes(t *testing.T) {
+	sentinels := []error{ErrNotRunning, ErrRateLimit, ErrTemporary, ErrSendFailed}
+
+	for _, sentinel := range sentinels {
+		wrapped := fmt.Errorf("context: %w", sentinel)
+		if !errors.Is(wrapped, sentinel) {
+			t.Errorf("wrapped %v should match itself", sentinel)
+		}
+
+		// Verify it doesn't match other sentinel errors
+		for _, other := range sentinels {
+			if other == sentinel {
+				continue
+			}
+			if errors.Is(wrapped, other) {
+				t.Errorf("wrapped %v should not match %v", sentinel, other)
+			}
+		}
+	}
+}
+
+func TestErrorMessages(t *testing.T) {
+	tests := []struct {
+		err  error
+		want string
+	}{
+		{ErrNotRunning, "channel not running"},
+		{ErrRateLimit, "rate limited"},
+		{ErrTemporary, "temporary failure"},
+		{ErrSendFailed, "send failed"},
+	}
+
+	for _, tt := range tests {
+		if got := tt.err.Error(); got != tt.want {
+			t.Errorf("error message = %q, want %q", got, tt.want)
+		}
+	}
+}
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 37af01796..1bc321cec 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -8,8 +8,13 @@ package channels
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"math"
 	"sync"
+	"time"
+
+	"golang.org/x/time/rate"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/config"
@@ -19,12 +24,28 @@ import (
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
-const defaultChannelQueueSize = 100
+const (
+	defaultChannelQueueSize = 100
+	defaultRateLimit        = 10 // default 10 msg/s
+	maxRetries              = 3
+	rateLimitDelay          = 1 * time.Second
+	baseBackoff             = 500 * time.Millisecond
+	maxBackoff              = 8 * time.Second
+)
+
+// channelRateConfig maps channel name to per-second rate limit.
+var channelRateConfig = map[string]float64{
+	"telegram": 20,
+	"discord":  1,
+	"slack":    1,
+	"line":     10,
+}
 
 type channelWorker struct {
-	ch    Channel
-	queue chan bus.OutboundMessage
-	done  chan struct{}
+	ch      Channel
+	queue   chan bus.OutboundMessage
+	done    chan struct{}
+	limiter *rate.Limiter
 }
 
 type Manager struct {
@@ -83,11 +104,7 @@ func (m *Manager) initChannel(name, displayName string) {
 			}
 		}
 		m.channels[name] = ch
-		m.workers[name] = &channelWorker{
-			ch:    ch,
-			queue: make(chan bus.OutboundMessage, defaultChannelQueueSize),
-			done:  make(chan struct{}),
-		}
+		m.workers[name] = newChannelWorker(name, ch)
 		logger.InfoCF("channels", "Channel enabled successfully", map[string]any{
 			"channel": displayName,
 		})
@@ -227,6 +244,23 @@ func (m *Manager) StopAll(ctx context.Context) error {
 	return nil
 }
 
+// newChannelWorker creates a channelWorker with a rate limiter configured
+// for the given channel name.
+func newChannelWorker(name string, ch Channel) *channelWorker {
+	rateVal := float64(defaultRateLimit)
+	if r, ok := channelRateConfig[name]; ok {
+		rateVal = r
+	}
+	burst := int(math.Max(1, math.Ceil(rateVal/2)))
+
+	return &channelWorker{
+		ch:      ch,
+		queue:   make(chan bus.OutboundMessage, defaultChannelQueueSize),
+		done:    make(chan struct{}),
+		limiter: rate.NewLimiter(rate.Limit(rateVal), burst),
+	}
+}
+
 // runWorker processes outbound messages for a single channel, splitting
 // messages that exceed the channel's maximum message length.
 func (m *Manager) runWorker(ctx context.Context, name string, w *channelWorker) {
@@ -246,18 +280,10 @@ func (m *Manager) runWorker(ctx context.Context, name string, w *channelWorker)
 				for _, chunk := range chunks {
 					chunkMsg := msg
 					chunkMsg.Content = chunk
-					if err := w.ch.Send(ctx, chunkMsg); err != nil {
-						logger.ErrorCF("channels", "Error sending chunk", map[string]any{
-							"channel": name, "error": err.Error(),
-						})
-					}
+					m.sendWithRetry(ctx, name, w, chunkMsg)
 				}
 			} else {
-				if err := w.ch.Send(ctx, msg); err != nil {
-					logger.ErrorCF("channels", "Error sending message", map[string]any{
-						"channel": name, "error": err.Error(),
-					})
-				}
+				m.sendWithRetry(ctx, name, w, msg)
 			}
 		case <-ctx.Done():
 			return
@@ -265,6 +291,63 @@ func (m *Manager) runWorker(ctx context.Context, name string, w *channelWorker)
 	}
 }
 
+// sendWithRetry sends a message through the channel with rate limiting and
+// retry logic. It classifies errors to determine the retry strategy:
+//   - ErrNotRunning / ErrSendFailed: permanent, no retry
+//   - ErrRateLimit: fixed delay retry
+//   - ErrTemporary / unknown: exponential backoff retry
+func (m *Manager) sendWithRetry(ctx context.Context, name string, w *channelWorker, msg bus.OutboundMessage) {
+	// Rate limit: wait for token
+	if err := w.limiter.Wait(ctx); err != nil {
+		// ctx cancelled, shutting down
+		return
+	}
+
+	var lastErr error
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		lastErr = w.ch.Send(ctx, msg)
+		if lastErr == nil {
+			return
+		}
+
+		// Permanent failures — don't retry
+		if errors.Is(lastErr, ErrNotRunning) || errors.Is(lastErr, ErrSendFailed) {
+			break
+		}
+
+		// Last attempt exhausted — don't sleep
+		if attempt == maxRetries {
+			break
+		}
+
+		// Rate limit error — fixed delay
+		if errors.Is(lastErr, ErrRateLimit) {
+			select {
+			case <-time.After(rateLimitDelay):
+				continue
+			case <-ctx.Done():
+				return
+			}
+		}
+
+		// ErrTemporary or unknown error — exponential backoff
+		backoff := min(time.Duration(float64(baseBackoff)*math.Pow(2, float64(attempt))), maxBackoff)
+		select {
+		case <-time.After(backoff):
+		case <-ctx.Done():
+			return
+		}
+	}
+
+	// All retries exhausted or permanent failure
+	logger.ErrorCF("channels", "Send failed", map[string]any{
+		"channel": name,
+		"chat_id": msg.ChatID,
+		"error":   lastErr.Error(),
+		"retries": maxRetries,
+	})
+}
+
 func (m *Manager) dispatchOutbound(ctx context.Context) {
 	logger.InfoC("channels", "Outbound dispatcher started")
 
@@ -343,11 +426,7 @@ func (m *Manager) RegisterChannel(name string, channel Channel) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.channels[name] = channel
-	m.workers[name] = &channelWorker{
-		ch:    channel,
-		queue: make(chan bus.OutboundMessage, defaultChannelQueueSize),
-		done:  make(chan struct{}),
-	}
+	m.workers[name] = newChannelWorker(name, channel)
 }
 
 func (m *Manager) UnregisterChannel(name string) {
diff --git a/pkg/channels/manager_test.go b/pkg/channels/manager_test.go
new file mode 100644
index 000000000..162c9f8c9
--- /dev/null
+++ b/pkg/channels/manager_test.go
@@ -0,0 +1,418 @@
+package channels
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"golang.org/x/time/rate"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+)
+
+// mockChannel is a test double that delegates Send to a configurable function.
+type mockChannel struct {
+	BaseChannel
+	sendFn func(ctx context.Context, msg bus.OutboundMessage) error
+}
+
+func (m *mockChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	return m.sendFn(ctx, msg)
+}
+
+func (m *mockChannel) Start(ctx context.Context) error { return nil }
+func (m *mockChannel) Stop(ctx context.Context) error  { return nil }
+
+// newTestManager creates a minimal Manager suitable for unit tests.
+func newTestManager() *Manager {
+	return &Manager{
+		channels: make(map[string]Channel),
+		workers:  make(map[string]*channelWorker),
+	}
+}
+
+func TestSendWithRetry_Success(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			return nil
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	if callCount != 1 {
+		t.Fatalf("expected 1 Send call, got %d", callCount)
+	}
+}
+
+func TestSendWithRetry_TemporaryThenSuccess(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			if callCount <= 2 {
+				return fmt.Errorf("network error: %w", ErrTemporary)
+			}
+			return nil
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	if callCount != 3 {
+		t.Fatalf("expected 3 Send calls (2 failures + 1 success), got %d", callCount)
+	}
+}
+
+func TestSendWithRetry_PermanentFailure(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			return fmt.Errorf("bad chat ID: %w", ErrSendFailed)
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	if callCount != 1 {
+		t.Fatalf("expected 1 Send call (no retry for permanent failure), got %d", callCount)
+	}
+}
+
+func TestSendWithRetry_NotRunning(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			return ErrNotRunning
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	if callCount != 1 {
+		t.Fatalf("expected 1 Send call (no retry for ErrNotRunning), got %d", callCount)
+	}
+}
+
+func TestSendWithRetry_RateLimitRetry(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			if callCount == 1 {
+				return fmt.Errorf("429: %w", ErrRateLimit)
+			}
+			return nil
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	start := time.Now()
+	m.sendWithRetry(ctx, "test", w, msg)
+	elapsed := time.Since(start)
+
+	if callCount != 2 {
+		t.Fatalf("expected 2 Send calls (1 rate limit + 1 success), got %d", callCount)
+	}
+	// Should have waited at least rateLimitDelay (1s) but allow some slack
+	if elapsed < 900*time.Millisecond {
+		t.Fatalf("expected at least ~1s delay for rate limit retry, got %v", elapsed)
+	}
+}
+
+func TestSendWithRetry_MaxRetriesExhausted(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			return fmt.Errorf("timeout: %w", ErrTemporary)
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	expected := maxRetries + 1 // initial attempt + maxRetries retries
+	if callCount != expected {
+		t.Fatalf("expected %d Send calls, got %d", expected, callCount)
+	}
+}
+
+func TestSendWithRetry_UnknownError(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			if callCount == 1 {
+				return errors.New("random unexpected error")
+			}
+			return nil
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	if callCount != 2 {
+		t.Fatalf("expected 2 Send calls (unknown error treated as temporary), got %d", callCount)
+	}
+}
+
+func TestSendWithRetry_ContextCancelled(t *testing.T) {
+	m := newTestManager()
+	var callCount int
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callCount++
+			return fmt.Errorf("timeout: %w", ErrTemporary)
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	// Cancel context after first Send attempt returns
+	ch.sendFn = func(_ context.Context, _ bus.OutboundMessage) error {
+		callCount++
+		cancel()
+		return fmt.Errorf("timeout: %w", ErrTemporary)
+	}
+
+	m.sendWithRetry(ctx, "test", w, msg)
+
+	// Should have called Send once, then noticed ctx cancelled during backoff
+	if callCount != 1 {
+		t.Fatalf("expected 1 Send call before context cancellation, got %d", callCount)
+	}
+}
+
+func TestWorkerRateLimiter(t *testing.T) {
+	m := newTestManager()
+
+	var mu sync.Mutex
+	var sendTimes []time.Time
+
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			mu.Lock()
+			sendTimes = append(sendTimes, time.Now())
+			mu.Unlock()
+			return nil
+		},
+	}
+
+	// Create a worker with a low rate: 2 msg/s, burst 1
+	w := &channelWorker{
+		ch:      ch,
+		queue:   make(chan bus.OutboundMessage, 10),
+		done:    make(chan struct{}),
+		limiter: rate.NewLimiter(2, 1),
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	go m.runWorker(ctx, "test", w)
+
+	// Enqueue 4 messages
+	for i := 0; i < 4; i++ {
+		w.queue <- bus.OutboundMessage{Channel: "test", ChatID: "1", Content: fmt.Sprintf("msg%d", i)}
+	}
+
+	// Wait enough time for all messages to be sent (4 msgs at 2/s = ~2s, give extra margin)
+	time.Sleep(3 * time.Second)
+
+	mu.Lock()
+	times := make([]time.Time, len(sendTimes))
+	copy(times, sendTimes)
+	mu.Unlock()
+
+	if len(times) != 4 {
+		t.Fatalf("expected 4 sends, got %d", len(times))
+	}
+
+	// Verify rate limiting: total duration should be at least 1s
+	// (first message immediate, then ~500ms between each subsequent one at 2/s)
+	totalDuration := times[len(times)-1].Sub(times[0])
+	if totalDuration < 1*time.Second {
+		t.Fatalf("expected total duration >= 1s for 4 msgs at 2/s rate, got %v", totalDuration)
+	}
+}
+
+func TestNewChannelWorker_DefaultRate(t *testing.T) {
+	ch := &mockChannel{}
+	w := newChannelWorker("unknown_channel", ch)
+
+	if w.limiter == nil {
+		t.Fatal("expected limiter to be non-nil")
+	}
+	if w.limiter.Limit() != rate.Limit(defaultRateLimit) {
+		t.Fatalf("expected rate limit %v, got %v", rate.Limit(defaultRateLimit), w.limiter.Limit())
+	}
+}
+
+func TestNewChannelWorker_ConfiguredRate(t *testing.T) {
+	ch := &mockChannel{}
+
+	for name, expectedRate := range channelRateConfig {
+		w := newChannelWorker(name, ch)
+		if w.limiter.Limit() != rate.Limit(expectedRate) {
+			t.Fatalf("channel %s: expected rate %v, got %v", name, expectedRate, w.limiter.Limit())
+		}
+	}
+}
+
+func TestRunWorker_MessageSplitting(t *testing.T) {
+	m := newTestManager()
+
+	var mu sync.Mutex
+	var received []string
+
+	ch := &mockChannelWithLength{
+		mockChannel: mockChannel{
+			sendFn: func(_ context.Context, msg bus.OutboundMessage) error {
+				mu.Lock()
+				received = append(received, msg.Content)
+				mu.Unlock()
+				return nil
+			},
+		},
+		maxLen: 5,
+	}
+
+	w := &channelWorker{
+		ch:      ch,
+		queue:   make(chan bus.OutboundMessage, 10),
+		done:    make(chan struct{}),
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	go m.runWorker(ctx, "test", w)
+
+	// Send a message that should be split
+	w.queue <- bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello world"}
+
+	time.Sleep(100 * time.Millisecond)
+
+	mu.Lock()
+	count := len(received)
+	mu.Unlock()
+
+	if count < 2 {
+		t.Fatalf("expected message to be split into at least 2 chunks, got %d", count)
+	}
+}
+
+// mockChannelWithLength implements MessageLengthProvider.
+type mockChannelWithLength struct {
+	mockChannel
+	maxLen int
+}
+
+func (m *mockChannelWithLength) MaxMessageLength() int {
+	return m.maxLen
+}
+
+func TestSendWithRetry_ExponentialBackoff(t *testing.T) {
+	m := newTestManager()
+
+	var callTimes []time.Time
+	var callCount atomic.Int32
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			callTimes = append(callTimes, time.Now())
+			callCount.Add(1)
+			return fmt.Errorf("timeout: %w", ErrTemporary)
+		},
+	}
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	ctx := context.Background()
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}
+
+	start := time.Now()
+	m.sendWithRetry(ctx, "test", w, msg)
+	totalElapsed := time.Since(start)
+
+	// With maxRetries=3: attempts at 0, ~500ms, ~1.5s, ~3.5s
+	// Total backoff: 500ms + 1s + 2s = 3.5s
+	// Allow some margin
+	if totalElapsed < 3*time.Second {
+		t.Fatalf("expected total elapsed >= 3s for exponential backoff, got %v", totalElapsed)
+	}
+
+	if int(callCount.Load()) != maxRetries+1 {
+		t.Fatalf("expected %d calls, got %d", maxRetries+1, callCount.Load())
+	}
+}

From 24e2ed79c08e31367e8c3352944fc0d5a5940415 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 00:44:45 +0800
Subject: [PATCH 39/52] refactor(bus): fix deadlock and concurrency issues in
 MessageBus
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PublishInbound/PublishOutbound held RLock during blocking channel sends,
deadlocking against Close() which needs a write lock when the buffer is
full. ConsumeInbound/SubscribeOutbound used bare receives instead of
comma-ok, causing zero-value processing or busy loops after close.

Replace sync.RWMutex+bool with atomic.Bool+done channel so Publish
methods use a lock-free 3-way select (send / done / ctx.Done). Add
context.Context parameter to both Publish methods so callers can cancel
or timeout blocked sends. Close() now only sets the atomic flag and
closes the done channel—never closes the data channels—eliminating
send-on-closed-channel panics.

- Remove dead code: RegisterHandler, GetHandler, handlers map,
  MessageHandler type (zero callers across the whole repo)
- Add ErrBusClosed sentinel error
- Update all 10 caller sites to pass context
- Add msgBus.Close() to gateway and agent shutdown flows
- Add pkg/bus/bus_test.go with 11 test cases covering basic round-trip,
  context cancellation, closed-bus behavior, concurrent publish+close,
  full-buffer timeout, and idempotent Close
---
 cmd/picoclaw/cmd_agent.go   |   1 +
 cmd/picoclaw/cmd_gateway.go |   1 +
 pkg/agent/loop.go           |  12 +-
 pkg/bus/bus.go              |  81 +++++++------
 pkg/bus/bus_test.go         | 229 ++++++++++++++++++++++++++++++++++++
 pkg/bus/types.go            |   2 -
 pkg/channels/base.go        |   2 +-
 pkg/devices/service.go      |   2 +-
 pkg/heartbeat/service.go    |   3 +-
 pkg/tools/cron.go           |   4 +-
 pkg/tools/subagent.go       |   2 +-
 11 files changed, 284 insertions(+), 55 deletions(-)
 create mode 100644 pkg/bus/bus_test.go

diff --git a/cmd/picoclaw/cmd_agent.go b/cmd/picoclaw/cmd_agent.go
index 8658c9d32..1c92e0b6c 100644
--- a/cmd/picoclaw/cmd_agent.go
+++ b/cmd/picoclaw/cmd_agent.go
@@ -70,6 +70,7 @@ func agentCmd() {
 	}
 
 	msgBus := bus.NewMessageBus()
+	defer msgBus.Close()
 	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
 
 	// Print agent startup info (only for interactive mode)
diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 3c2cb021d..3b914f6ae 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -228,6 +228,7 @@ func gatewayCmd() {
 
 	fmt.Println("\nShutting down...")
 	cancel()
+	msgBus.Close()
 	healthServer.Stop(context.Background())
 	deviceService.Stop()
 	heartbeatService.Stop()
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 97569bef7..e243a6fdb 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -120,7 +120,7 @@ func registerSharedTools(
 		// Message tool
 		messageTool := tools.NewMessageTool()
 		messageTool.SetSendCallback(func(channel, chatID, content string) error {
-			msgBus.PublishOutbound(bus.OutboundMessage{
+			msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 				Channel: channel,
 				ChatID:  chatID,
 				Content: content,
@@ -202,7 +202,7 @@ func (al *AgentLoop) Run(ctx context.Context) error {
 					}
 
 					if !alreadySent {
-						al.bus.PublishOutbound(bus.OutboundMessage{
+						al.bus.PublishOutbound(ctx, bus.OutboundMessage{
 							Channel: msg.Channel,
 							ChatID:  msg.ChatID,
 							Content: response,
@@ -471,7 +471,7 @@ func (al *AgentLoop) runAgentLoop(ctx context.Context, agent *AgentInstance, opt
 
 	// 8. Optional: send response via bus
 	if opts.SendResponse {
-		al.bus.PublishOutbound(bus.OutboundMessage{
+		al.bus.PublishOutbound(ctx, bus.OutboundMessage{
 			Channel: opts.Channel,
 			ChatID:  opts.ChatID,
 			Content: finalContent,
@@ -586,7 +586,7 @@ func (al *AgentLoop) runLLMIteration(
 				})
 
 				if retry == 0 && !constants.IsInternalChannel(opts.Channel) {
-					al.bus.PublishOutbound(bus.OutboundMessage{
+					al.bus.PublishOutbound(ctx, bus.OutboundMessage{
 						Channel: opts.Channel,
 						ChatID:  opts.ChatID,
 						Content: "Context window exceeded. Compressing history and retrying...",
@@ -715,7 +715,7 @@ func (al *AgentLoop) runLLMIteration(
 
 			// Send ForUser content to user immediately if not Silent
 			if !toolResult.Silent && toolResult.ForUser != "" && opts.SendResponse {
-				al.bus.PublishOutbound(bus.OutboundMessage{
+				al.bus.PublishOutbound(ctx, bus.OutboundMessage{
 					Channel: opts.Channel,
 					ChatID:  opts.ChatID,
 					Content: toolResult.ForUser,
@@ -780,7 +780,7 @@ func (al *AgentLoop) maybeSummarize(agent *AgentInstance, sessionKey, channel, c
 			go func() {
 				defer al.summarizing.Delete(summarizeKey)
 				if !constants.IsInternalChannel(channel) {
-					al.bus.PublishOutbound(bus.OutboundMessage{
+					al.bus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 						Channel: channel,
 						ChatID:  chatID,
 						Content: "Memory threshold reached. Optimizing conversation history...",
diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go
index 58c0a25d5..100ddc456 100644
--- a/pkg/bus/bus.go
+++ b/pkg/bus/bus.go
@@ -2,81 +2,80 @@ package bus
 
 import (
 	"context"
-	"sync"
+	"errors"
+	"sync/atomic"
 )
 
+// ErrBusClosed is returned when publishing to a closed MessageBus.
+var ErrBusClosed = errors.New("message bus closed")
+
 type MessageBus struct {
 	inbound  chan InboundMessage
 	outbound chan OutboundMessage
-	handlers map[string]MessageHandler
-	closed   bool
-	mu       sync.RWMutex
+	done     chan struct{}
+	closed   atomic.Bool
 }
 
 func NewMessageBus() *MessageBus {
 	return &MessageBus{
 		inbound:  make(chan InboundMessage, 100),
 		outbound: make(chan OutboundMessage, 100),
-		handlers: make(map[string]MessageHandler),
+		done:     make(chan struct{}),
 	}
 }
 
-func (mb *MessageBus) PublishInbound(msg InboundMessage) {
-	mb.mu.RLock()
-	defer mb.mu.RUnlock()
-	if mb.closed {
-		return
+func (mb *MessageBus) PublishInbound(ctx context.Context, msg InboundMessage) error {
+	if mb.closed.Load() {
+		return ErrBusClosed
+	}
+	select {
+	case mb.inbound <- msg:
+		return nil
+	case <-mb.done:
+		return ErrBusClosed
+	case <-ctx.Done():
+		return ctx.Err()
 	}
-	mb.inbound <- msg
 }
 
 func (mb *MessageBus) ConsumeInbound(ctx context.Context) (InboundMessage, bool) {
 	select {
-	case msg := <-mb.inbound:
-		return msg, true
+	case msg, ok := <-mb.inbound:
+		return msg, ok
+	case <-mb.done:
+		return InboundMessage{}, false
 	case <-ctx.Done():
 		return InboundMessage{}, false
 	}
 }
 
-func (mb *MessageBus) PublishOutbound(msg OutboundMessage) {
-	mb.mu.RLock()
-	defer mb.mu.RUnlock()
-	if mb.closed {
-		return
+func (mb *MessageBus) PublishOutbound(ctx context.Context, msg OutboundMessage) error {
+	if mb.closed.Load() {
+		return ErrBusClosed
+	}
+	select {
+	case mb.outbound <- msg:
+		return nil
+	case <-mb.done:
+		return ErrBusClosed
+	case <-ctx.Done():
+		return ctx.Err()
 	}
-	mb.outbound <- msg
 }
 
 func (mb *MessageBus) SubscribeOutbound(ctx context.Context) (OutboundMessage, bool) {
 	select {
-	case msg := <-mb.outbound:
-		return msg, true
+	case msg, ok := <-mb.outbound:
+		return msg, ok
+	case <-mb.done:
+		return OutboundMessage{}, false
 	case <-ctx.Done():
 		return OutboundMessage{}, false
 	}
 }
 
-func (mb *MessageBus) RegisterHandler(channel string, handler MessageHandler) {
-	mb.mu.Lock()
-	defer mb.mu.Unlock()
-	mb.handlers[channel] = handler
-}
-
-func (mb *MessageBus) GetHandler(channel string) (MessageHandler, bool) {
-	mb.mu.RLock()
-	defer mb.mu.RUnlock()
-	handler, ok := mb.handlers[channel]
-	return handler, ok
-}
-
 func (mb *MessageBus) Close() {
-	mb.mu.Lock()
-	defer mb.mu.Unlock()
-	if mb.closed {
-		return
+	if mb.closed.CompareAndSwap(false, true) {
+		close(mb.done)
 	}
-	mb.closed = true
-	close(mb.inbound)
-	close(mb.outbound)
 }
diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go
new file mode 100644
index 000000000..47826824e
--- /dev/null
+++ b/pkg/bus/bus_test.go
@@ -0,0 +1,229 @@
+package bus
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestPublishConsume(t *testing.T) {
+	mb := NewMessageBus()
+	defer mb.Close()
+
+	ctx := context.Background()
+
+	msg := InboundMessage{
+		Channel:  "test",
+		SenderID: "user1",
+		ChatID:   "chat1",
+		Content:  "hello",
+	}
+
+	if err := mb.PublishInbound(ctx, msg); err != nil {
+		t.Fatalf("PublishInbound failed: %v", err)
+	}
+
+	got, ok := mb.ConsumeInbound(ctx)
+	if !ok {
+		t.Fatal("ConsumeInbound returned ok=false")
+	}
+	if got.Content != "hello" {
+		t.Fatalf("expected content 'hello', got %q", got.Content)
+	}
+	if got.Channel != "test" {
+		t.Fatalf("expected channel 'test', got %q", got.Channel)
+	}
+}
+
+func TestPublishOutboundSubscribe(t *testing.T) {
+	mb := NewMessageBus()
+	defer mb.Close()
+
+	ctx := context.Background()
+
+	msg := OutboundMessage{
+		Channel: "telegram",
+		ChatID:  "123",
+		Content: "world",
+	}
+
+	if err := mb.PublishOutbound(ctx, msg); err != nil {
+		t.Fatalf("PublishOutbound failed: %v", err)
+	}
+
+	got, ok := mb.SubscribeOutbound(ctx)
+	if !ok {
+		t.Fatal("SubscribeOutbound returned ok=false")
+	}
+	if got.Content != "world" {
+		t.Fatalf("expected content 'world', got %q", got.Content)
+	}
+}
+
+func TestPublishInbound_ContextCancel(t *testing.T) {
+	mb := NewMessageBus()
+	defer mb.Close()
+
+	// Fill the buffer
+	ctx := context.Background()
+	for i := 0; i < 100; i++ {
+		if err := mb.PublishInbound(ctx, InboundMessage{Content: "fill"}); err != nil {
+			t.Fatalf("fill failed at %d: %v", i, err)
+		}
+	}
+
+	// Now buffer is full; publish with a cancelled context
+	cancelCtx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	err := mb.PublishInbound(cancelCtx, InboundMessage{Content: "overflow"})
+	if err == nil {
+		t.Fatal("expected error from cancelled context, got nil")
+	}
+	if err != context.Canceled {
+		t.Fatalf("expected context.Canceled, got %v", err)
+	}
+}
+
+func TestPublishInbound_BusClosed(t *testing.T) {
+	mb := NewMessageBus()
+	mb.Close()
+
+	err := mb.PublishInbound(context.Background(), InboundMessage{Content: "test"})
+	if err != ErrBusClosed {
+		t.Fatalf("expected ErrBusClosed, got %v", err)
+	}
+}
+
+func TestPublishOutbound_BusClosed(t *testing.T) {
+	mb := NewMessageBus()
+	mb.Close()
+
+	err := mb.PublishOutbound(context.Background(), OutboundMessage{Content: "test"})
+	if err != ErrBusClosed {
+		t.Fatalf("expected ErrBusClosed, got %v", err)
+	}
+}
+
+func TestConsumeInbound_ContextCancel(t *testing.T) {
+	mb := NewMessageBus()
+	defer mb.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	_, ok := mb.ConsumeInbound(ctx)
+	if ok {
+		t.Fatal("expected ok=false when context is cancelled")
+	}
+}
+
+func TestConsumeInbound_BusClosed(t *testing.T) {
+	mb := NewMessageBus()
+	mb.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	_, ok := mb.ConsumeInbound(ctx)
+	if ok {
+		t.Fatal("expected ok=false when bus is closed")
+	}
+}
+
+func TestSubscribeOutbound_BusClosed(t *testing.T) {
+	mb := NewMessageBus()
+	mb.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	_, ok := mb.SubscribeOutbound(ctx)
+	if ok {
+		t.Fatal("expected ok=false when bus is closed")
+	}
+}
+
+func TestConcurrentPublishClose(t *testing.T) {
+	mb := NewMessageBus()
+	ctx := context.Background()
+
+	const numGoroutines = 100
+	var wg sync.WaitGroup
+	wg.Add(numGoroutines + 1)
+
+	// Spawn many goroutines trying to publish
+	for i := 0; i < numGoroutines; i++ {
+		go func() {
+			defer wg.Done()
+			// Use a short timeout context so we don't block forever after close
+			publishCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
+			defer cancel()
+			// Errors are expected; we just must not panic or deadlock
+			_ = mb.PublishInbound(publishCtx, InboundMessage{Content: "concurrent"})
+		}()
+	}
+
+	// Close from another goroutine
+	go func() {
+		defer wg.Done()
+		time.Sleep(5 * time.Millisecond)
+		mb.Close()
+	}()
+
+	// Must complete without deadlock
+	done := make(chan struct{})
+	go func() {
+		wg.Wait()
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		// success
+	case <-time.After(5 * time.Second):
+		t.Fatal("test timed out - possible deadlock")
+	}
+}
+
+func TestPublishInbound_FullBuffer(t *testing.T) {
+	mb := NewMessageBus()
+	defer mb.Close()
+
+	ctx := context.Background()
+
+	// Fill the buffer
+	for i := 0; i < 100; i++ {
+		if err := mb.PublishInbound(ctx, InboundMessage{Content: "fill"}); err != nil {
+			t.Fatalf("fill failed at %d: %v", i, err)
+		}
+	}
+
+	// Buffer is full; publish with short timeout
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
+	defer cancel()
+
+	err := mb.PublishInbound(timeoutCtx, InboundMessage{Content: "overflow"})
+	if err == nil {
+		t.Fatal("expected error when buffer is full and context times out")
+	}
+	if err != context.DeadlineExceeded {
+		t.Fatalf("expected context.DeadlineExceeded, got %v", err)
+	}
+}
+
+func TestCloseIdempotent(t *testing.T) {
+	mb := NewMessageBus()
+
+	// Multiple Close calls must not panic
+	mb.Close()
+	mb.Close()
+	mb.Close()
+
+	// After close, publish should return ErrBusClosed
+	err := mb.PublishInbound(context.Background(), InboundMessage{Content: "test"})
+	if err != ErrBusClosed {
+		t.Fatalf("expected ErrBusClosed after multiple closes, got %v", err)
+	}
+}
diff --git a/pkg/bus/types.go b/pkg/bus/types.go
index e49713eb8..358829c55 100644
--- a/pkg/bus/types.go
+++ b/pkg/bus/types.go
@@ -24,5 +24,3 @@ type OutboundMessage struct {
 	ChatID  string `json:"chat_id"`
 	Content string `json:"content"`
 }
-
-type MessageHandler func(InboundMessage) error
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index d967d9e91..adacb8c78 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -143,7 +143,7 @@ func (c *BaseChannel) HandleMessage(
 		Metadata:   metadata,
 	}
 
-	c.bus.PublishInbound(msg)
+	c.bus.PublishInbound(context.TODO(), msg)
 }
 
 func (c *BaseChannel) SetRunning(running bool) {
diff --git a/pkg/devices/service.go b/pkg/devices/service.go
index 1541d3c57..408e1c8aa 100644
--- a/pkg/devices/service.go
+++ b/pkg/devices/service.go
@@ -127,7 +127,7 @@ func (s *Service) sendNotification(ev *events.DeviceEvent) {
 	}
 
 	msg := ev.FormatMessage()
-	msgBus.PublishOutbound(bus.OutboundMessage{
+	msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 		Channel: platform,
 		ChatID:  userID,
 		Content: msg,
diff --git a/pkg/heartbeat/service.go b/pkg/heartbeat/service.go
index 75d6248b9..62b321955 100644
--- a/pkg/heartbeat/service.go
+++ b/pkg/heartbeat/service.go
@@ -7,6 +7,7 @@
 package heartbeat
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -307,7 +308,7 @@ func (hs *HeartbeatService) sendResponse(response string) {
 		return
 	}
 
-	msgBus.PublishOutbound(bus.OutboundMessage{
+	msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 		Channel: platform,
 		ChatID:  userID,
 		Content: response,
diff --git a/pkg/tools/cron.go b/pkg/tools/cron.go
index 562fffc84..3c13f5968 100644
--- a/pkg/tools/cron.go
+++ b/pkg/tools/cron.go
@@ -294,7 +294,7 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string {
 			output = fmt.Sprintf("Scheduled command '%s' executed:\n%s", job.Payload.Command, result.ForLLM)
 		}
 
-		t.msgBus.PublishOutbound(bus.OutboundMessage{
+		t.msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 			Channel: channel,
 			ChatID:  chatID,
 			Content: output,
@@ -304,7 +304,7 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string {
 
 	// If deliver=true, send message directly without agent processing
 	if job.Payload.Deliver {
-		t.msgBus.PublishOutbound(bus.OutboundMessage{
+		t.msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
 			Channel: channel,
 			ChatID:  chatID,
 			Content: job.Payload.Message,
diff --git a/pkg/tools/subagent.go b/pkg/tools/subagent.go
index 91ebff636..99821daf9 100644
--- a/pkg/tools/subagent.go
+++ b/pkg/tools/subagent.go
@@ -218,7 +218,7 @@ After completing the task, provide a clear summary of what was done.`
 	// Send announce message back to main agent
 	if sm.bus != nil {
 		announceContent := fmt.Sprintf("Task '%s' completed.\n\nResult:\n%s", task.Label, task.Result)
-		sm.bus.PublishInbound(bus.InboundMessage{
+		sm.bus.PublishInbound(context.TODO(), bus.InboundMessage{
 			Channel:  "system",
 			SenderID: fmt.Sprintf("subagent:%s", task.ID),
 			// Format: "original_channel:original_chat_id" for routing back

From cc92a6281251c008059c0b2a069cb12631affac0 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 01:45:48 +0800
Subject: [PATCH 40/52] refactor(channels): standardize Send error
 classification with sentinel types

All 12 channel Send methods now return proper sentinel errors (ErrNotRunning,
ErrTemporary, ErrRateLimit, ErrSendFailed) instead of plain fmt.Errorf strings,
enabling Manager's sendWithRetry classification logic to actually work.

- Add ClassifySendError/ClassifyNetError helpers in errutil.go for HTTP-based channels
- LINE/WeCom Bot/WeCom App: use ClassifySendError for HTTP status-based classification
- SDK channels (Telegram/Discord/Slack/QQ/DingTalk/Feishu): wrap errors as ErrTemporary
- WebSocket channels (OneBot/WhatsApp/MaixCam): wrap write errors as ErrTemporary
- WhatsApp: add missing IsRunning() check in Send
- WhatsApp/OneBot/MaixCam: add ctx.Done() check before entering write path
- Telegram Stop: clean up placeholders sync.Map to prevent state leaks
---
 pkg/channels/dingtalk/dingtalk.go |  4 +-
 pkg/channels/discord/discord.go   |  6 +-
 pkg/channels/errutil.go           | 30 ++++++++++
 pkg/channels/errutil_test.go      | 97 +++++++++++++++++++++++++++++++
 pkg/channels/feishu/feishu_64.go  |  6 +-
 pkg/channels/line/line.go         |  6 +-
 pkg/channels/maixcam/maixcam.go   | 11 +++-
 pkg/channels/onebot/onebot.go     | 11 +++-
 pkg/channels/qq/qq.go             |  4 +-
 pkg/channels/slack/slack.go       |  4 +-
 pkg/channels/telegram/telegram.go | 15 +++--
 pkg/channels/wecom/app.go         | 16 ++++-
 pkg/channels/wecom/bot.go         |  9 ++-
 pkg/channels/whatsapp/whatsapp.go | 15 ++++-
 14 files changed, 204 insertions(+), 30 deletions(-)
 create mode 100644 pkg/channels/errutil.go
 create mode 100644 pkg/channels/errutil_test.go

diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index e051add1f..c49769761 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -96,7 +96,7 @@ func (c *DingTalkChannel) Stop(ctx context.Context) error {
 // Send sends a message to DingTalk via the chatbot reply API
 func (c *DingTalkChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("dingtalk channel not running")
+		return channels.ErrNotRunning
 	}
 
 	// Get session webhook from storage
@@ -197,7 +197,7 @@ func (c *DingTalkChannel) SendDirectReply(ctx context.Context, sessionWebhook, c
 		contentBytes,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to send reply: %w", err)
+		return fmt.Errorf("dingtalk send: %w", channels.ErrTemporary)
 	}
 
 	return nil
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 7977d32e1..d5524f7f9 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -113,7 +113,7 @@ func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 	c.stopTyping(msg.ChatID)
 
 	if !c.IsRunning() {
-		return fmt.Errorf("discord bot not running")
+		return channels.ErrNotRunning
 	}
 
 	channelID := msg.ChatID
@@ -142,11 +142,11 @@ func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content strin
 	select {
 	case err := <-done:
 		if err != nil {
-			return fmt.Errorf("failed to send discord message: %w", err)
+			return fmt.Errorf("discord send: %w", channels.ErrTemporary)
 		}
 		return nil
 	case <-sendCtx.Done():
-		return fmt.Errorf("send message timeout: %w", sendCtx.Err())
+		return sendCtx.Err()
 	}
 }
 
diff --git a/pkg/channels/errutil.go b/pkg/channels/errutil.go
new file mode 100644
index 000000000..319e3c980
--- /dev/null
+++ b/pkg/channels/errutil.go
@@ -0,0 +1,30 @@
+package channels
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// ClassifySendError wraps a raw error with the appropriate sentinel based on
+// an HTTP status code. Channels that perform HTTP API calls should use this
+// in their Send path.
+func ClassifySendError(statusCode int, rawErr error) error {
+	switch {
+	case statusCode == http.StatusTooManyRequests:
+		return fmt.Errorf("%w: %v", ErrRateLimit, rawErr)
+	case statusCode >= 500:
+		return fmt.Errorf("%w: %v", ErrTemporary, rawErr)
+	case statusCode >= 400:
+		return fmt.Errorf("%w: %v", ErrSendFailed, rawErr)
+	default:
+		return rawErr
+	}
+}
+
+// ClassifyNetError wraps a network/timeout error as ErrTemporary.
+func ClassifyNetError(err error) error {
+	if err == nil {
+		return nil
+	}
+	return fmt.Errorf("%w: %v", ErrTemporary, err)
+}
diff --git a/pkg/channels/errutil_test.go b/pkg/channels/errutil_test.go
new file mode 100644
index 000000000..e3d35f65b
--- /dev/null
+++ b/pkg/channels/errutil_test.go
@@ -0,0 +1,97 @@
+package channels
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestClassifySendError(t *testing.T) {
+	raw := fmt.Errorf("some API error")
+
+	tests := []struct {
+		name       string
+		statusCode int
+		wantIs     error
+		wantNil    bool
+	}{
+		{"429 -> ErrRateLimit", 429, ErrRateLimit, false},
+		{"500 -> ErrTemporary", 500, ErrTemporary, false},
+		{"502 -> ErrTemporary", 502, ErrTemporary, false},
+		{"503 -> ErrTemporary", 503, ErrTemporary, false},
+		{"400 -> ErrSendFailed", 400, ErrSendFailed, false},
+		{"403 -> ErrSendFailed", 403, ErrSendFailed, false},
+		{"404 -> ErrSendFailed", 404, ErrSendFailed, false},
+		{"200 -> raw error", 200, nil, false},
+		{"201 -> raw error", 201, nil, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ClassifySendError(tt.statusCode, raw)
+			if err == nil {
+				t.Fatal("expected non-nil error")
+			}
+			if tt.wantIs != nil {
+				if !errors.Is(err, tt.wantIs) {
+					t.Errorf("errors.Is(err, %v) = false, want true; err = %v", tt.wantIs, err)
+				}
+			} else {
+				// Should return the raw error unchanged
+				if err != raw {
+					t.Errorf("expected raw error to be returned unchanged for status %d, got %v", tt.statusCode, err)
+				}
+			}
+		})
+	}
+}
+
+func TestClassifySendErrorNoFalsePositive(t *testing.T) {
+	raw := fmt.Errorf("some error")
+
+	// 429 should NOT match ErrTemporary or ErrSendFailed
+	err := ClassifySendError(429, raw)
+	if errors.Is(err, ErrTemporary) {
+		t.Error("429 should not match ErrTemporary")
+	}
+	if errors.Is(err, ErrSendFailed) {
+		t.Error("429 should not match ErrSendFailed")
+	}
+
+	// 500 should NOT match ErrRateLimit or ErrSendFailed
+	err = ClassifySendError(500, raw)
+	if errors.Is(err, ErrRateLimit) {
+		t.Error("500 should not match ErrRateLimit")
+	}
+	if errors.Is(err, ErrSendFailed) {
+		t.Error("500 should not match ErrSendFailed")
+	}
+
+	// 400 should NOT match ErrRateLimit or ErrTemporary
+	err = ClassifySendError(400, raw)
+	if errors.Is(err, ErrRateLimit) {
+		t.Error("400 should not match ErrRateLimit")
+	}
+	if errors.Is(err, ErrTemporary) {
+		t.Error("400 should not match ErrTemporary")
+	}
+}
+
+func TestClassifyNetError(t *testing.T) {
+	t.Run("nil error returns nil", func(t *testing.T) {
+		if err := ClassifyNetError(nil); err != nil {
+			t.Errorf("expected nil, got %v", err)
+		}
+	})
+
+	t.Run("non-nil error wraps as ErrTemporary", func(t *testing.T) {
+		raw := fmt.Errorf("connection refused")
+		err := ClassifyNetError(raw)
+		if err == nil {
+			t.Fatal("expected non-nil error")
+		}
+		if !errors.Is(err, ErrTemporary) {
+			t.Errorf("errors.Is(err, ErrTemporary) = false, want true; err = %v", err)
+		}
+	})
+}
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index d67823974..5245cd99d 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -91,7 +91,7 @@ func (c *FeishuChannel) Stop(ctx context.Context) error {
 
 func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("feishu channel not running")
+		return channels.ErrNotRunning
 	}
 
 	if msg.ChatID == "" {
@@ -115,11 +115,11 @@ func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 
 	resp, err := c.client.Im.V1.Message.Create(ctx, req)
 	if err != nil {
-		return fmt.Errorf("failed to send feishu message: %w", err)
+		return fmt.Errorf("feishu send: %w", channels.ErrTemporary)
 	}
 
 	if !resp.Success() {
-		return fmt.Errorf("feishu api error: code=%d msg=%s", resp.Code, resp.Msg)
+		return fmt.Errorf("feishu api error (code=%d msg=%s): %w", resp.Code, resp.Msg, channels.ErrTemporary)
 	}
 
 	logger.DebugCF("feishu", "Feishu message sent", map[string]any{
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 272a53c6e..fd06334d5 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -491,7 +491,7 @@ func (c *LINEChannel) resolveChatID(source lineSource) string {
 // using a cached reply token, then falls back to the Push API.
 func (c *LINEChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("line channel not running")
+		return channels.ErrNotRunning
 	}
 
 	// Load and consume quote token for this chat
@@ -582,13 +582,13 @@ func (c *LINEChannel) callAPI(ctx context.Context, endpoint string, payload any)
 	client := &http.Client{Timeout: 30 * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("API request failed: %w", err)
+		return channels.ClassifyNetError(err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
 		respBody, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("LINE API error (status %d): %s", resp.StatusCode, string(respBody))
+		return channels.ClassifySendError(resp.StatusCode, fmt.Errorf("LINE API error: %s", string(respBody)))
 	}
 
 	return nil
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index 05213b095..b5b7259f9 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -215,7 +215,14 @@ func (c *MaixCamChannel) Stop(ctx context.Context) error {
 
 func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("maixcam channel not running")
+		return channels.ErrNotRunning
+	}
+
+	// Check ctx before entering write path
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
 	}
 
 	c.clientsMux.RLock()
@@ -246,7 +253,7 @@ func (c *MaixCamChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 				"client": conn.RemoteAddr().String(),
 				"error":  err.Error(),
 			})
-			sendErr = err
+			sendErr = fmt.Errorf("maixcam send: %w", channels.ErrTemporary)
 		}
 		_ = conn.SetWriteDeadline(time.Time{})
 	}
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index e2fe541f1..76950663e 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -373,7 +373,14 @@ func (c *OneBotChannel) Stop(ctx context.Context) error {
 
 func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("OneBot channel not running")
+		return channels.ErrNotRunning
+	}
+
+	// Check ctx before entering write path
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
 	}
 
 	c.mu.Lock()
@@ -412,7 +419,7 @@ func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 		logger.ErrorCF("onebot", "Failed to send message", map[string]any{
 			"error": err.Error(),
 		})
-		return err
+		return fmt.Errorf("onebot send: %w", channels.ErrTemporary)
 	}
 
 	if msgID, ok := c.pendingEmojiMsg.LoadAndDelete(msg.ChatID); ok {
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 429e23cbf..69f323e6e 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -114,7 +114,7 @@ func (c *QQChannel) Stop(ctx context.Context) error {
 
 func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("QQ bot not running")
+		return channels.ErrNotRunning
 	}
 
 	// 构造消息
@@ -128,7 +128,7 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 		logger.ErrorCF("qq", "Failed to send C2C message", map[string]any{
 			"error": err.Error(),
 		})
-		return err
+		return fmt.Errorf("qq send: %w", channels.ErrTemporary)
 	}
 
 	return nil
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index 53d7c0609..9e066e00a 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -112,7 +112,7 @@ func (c *SlackChannel) Stop(ctx context.Context) error {
 
 func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("slack channel not running")
+		return channels.ErrNotRunning
 	}
 
 	channelID, threadTS := parseSlackChatID(msg.ChatID)
@@ -130,7 +130,7 @@ func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 
 	_, _, err := c.api.PostMessageContext(ctx, channelID, opts...)
 	if err != nil {
-		return fmt.Errorf("failed to send slack message: %w", err)
+		return fmt.Errorf("slack send: %w", channels.ErrTemporary)
 	}
 
 	if ref, ok := c.pendingAcks.LoadAndDelete(msg.ChatID); ok {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index af7155799..a07eb6579 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -164,6 +164,12 @@ func (c *TelegramChannel) Stop(ctx context.Context) error {
 		return true
 	})
 
+	// Clean up placeholder state
+	c.placeholders.Range(func(key, value any) bool {
+		c.placeholders.Delete(key)
+		return true
+	})
+
 	// Stop the bot handler
 	if c.bh != nil {
 		c.bh.Stop()
@@ -179,12 +185,12 @@ func (c *TelegramChannel) Stop(ctx context.Context) error {
 
 func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("telegram bot not running")
+		return channels.ErrNotRunning
 	}
 
 	chatID, err := parseChatID(msg.ChatID)
 	if err != nil {
-		return fmt.Errorf("invalid chat ID: %w", err)
+		return fmt.Errorf("invalid chat ID %s: %w", msg.ChatID, channels.ErrSendFailed)
 	}
 
 	// Stop thinking animation
@@ -217,8 +223,9 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 			"error": err.Error(),
 		})
 		tgMsg.ParseMode = ""
-		_, err = c.bot.SendMessage(ctx, tgMsg)
-		return err
+		if _, err = c.bot.SendMessage(ctx, tgMsg); err != nil {
+			return fmt.Errorf("telegram send: %w", channels.ErrTemporary)
+		}
 	}
 
 	return nil
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index eb1711d75..41861e8fc 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -207,7 +207,7 @@ func (c *WeComAppChannel) Stop(ctx context.Context) error {
 // Send sends a message to WeCom user proactively using access token
 func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("wecom_app channel not running")
+		return channels.ErrNotRunning
 	}
 
 	accessToken := c.getAccessToken()
@@ -548,10 +548,15 @@ func (c *WeComAppChannel) sendTextMessage(ctx context.Context, accessToken, user
 	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
+		return channels.ClassifyNetError(err)
 	}
 	defer resp.Body.Close()
 
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return channels.ClassifySendError(resp.StatusCode, fmt.Errorf("wecom_app API error: %s", string(body)))
+	}
+
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return fmt.Errorf("failed to read response: %w", err)
@@ -603,10 +608,15 @@ func (c *WeComAppChannel) sendMarkdownMessage(ctx context.Context, accessToken,
 	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
+		return channels.ClassifyNetError(err)
 	}
 	defer resp.Body.Close()
 
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return channels.ClassifySendError(resp.StatusCode, fmt.Errorf("wecom_app API error: %s", string(body)))
+	}
+
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return fmt.Errorf("failed to read response: %w", err)
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index bbac8611a..7960802fb 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -166,7 +166,7 @@ func (c *WeComBotChannel) Stop(ctx context.Context) error {
 // For delayed responses, we use the webhook URL
 func (c *WeComBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	if !c.IsRunning() {
-		return fmt.Errorf("wecom channel not running")
+		return channels.ErrNotRunning
 	}
 
 	logger.DebugCF("wecom", "Sending message via webhook", map[string]any{
@@ -433,10 +433,15 @@ func (c *WeComBotChannel) sendWebhookReply(ctx context.Context, userID, content
 	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to send webhook reply: %w", err)
+		return channels.ClassifyNetError(err)
 	}
 	defer resp.Body.Close()
 
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return channels.ClassifySendError(resp.StatusCode, fmt.Errorf("webhook API error: %s", string(body)))
+	}
+
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return fmt.Errorf("failed to read response: %w", err)
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index b5f3e99d7..97032334f 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -94,11 +94,22 @@ func (c *WhatsAppChannel) Stop(ctx context.Context) error {
 }
 
 func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	// Check ctx before acquiring lock
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	if c.conn == nil {
-		return fmt.Errorf("whatsapp connection not established")
+		return fmt.Errorf("whatsapp connection not established: %w", channels.ErrTemporary)
 	}
 
 	payload := map[string]any{
@@ -115,7 +126,7 @@ func (c *WhatsAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 	if err := c.conn.WriteMessage(websocket.TextMessage, data); err != nil {
 		_ = c.conn.SetWriteDeadline(time.Time{})
-		return fmt.Errorf("failed to send message: %w", err)
+		return fmt.Errorf("whatsapp send: %w", channels.ErrTemporary)
 	}
 	_ = c.conn.SetWriteDeadline(time.Time{})
 

From d1551dc4233ad6171a8b801c28f66979e1c1deb3 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 02:39:09 +0800
Subject: [PATCH 41/52] refactor(channels): consolidate HTTP servers into
 shared server managed by Manager

Merge 3 independent channel HTTP servers (LINE :18791, WeCom Bot :18793,
WeCom App :18792) and the health server (:18790) into a single shared
HTTP server on the Gateway address. Channels implement WebhookHandler
and/or HealthChecker interfaces to register their handlers on the shared
mux. Also change Gateway default host from 0.0.0.0 to 127.0.0.1 for
security.
---
 cmd/picoclaw/cmd_gateway.go | 15 ++++----
 pkg/channels/line/line.go   | 53 ++++++++--------------------
 pkg/channels/manager.go     | 69 ++++++++++++++++++++++++++++++++++++-
 pkg/channels/webhook.go     | 20 +++++++++++
 pkg/channels/wecom/app.go   | 63 ++++++++++++++-------------------
 pkg/channels/wecom/bot.go   | 63 ++++++++++++++-------------------
 pkg/health/server.go        |  7 ++++
 7 files changed, 166 insertions(+), 124 deletions(-)
 create mode 100644 pkg/channels/webhook.go

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 3b914f6ae..4e6ec8bb3 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -6,7 +6,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -208,16 +207,15 @@ func gatewayCmd() {
 		fmt.Println("✓ Device event service started")
 	}
 
+	// Setup shared HTTP server with health endpoints and webhook handlers
+	healthServer := health.NewServer(cfg.Gateway.Host, cfg.Gateway.Port)
+	addr := fmt.Sprintf("%s:%d", cfg.Gateway.Host, cfg.Gateway.Port)
+	channelManager.SetupHTTPServer(addr, healthServer)
+
 	if err := channelManager.StartAll(ctx); err != nil {
 		fmt.Printf("Error starting channels: %v\n", err)
 	}
 
-	healthServer := health.NewServer(cfg.Gateway.Host, cfg.Gateway.Port)
-	go func() {
-		if err := healthServer.Start(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("health", "Health server error", map[string]any{"error": err.Error()})
-		}
-	}()
 	fmt.Printf("✓ Health endpoints available at http://%s:%d/health and /ready\n", cfg.Gateway.Host, cfg.Gateway.Port)
 
 	go agentLoop.Run(ctx)
@@ -229,12 +227,11 @@ func gatewayCmd() {
 	fmt.Println("\nShutting down...")
 	cancel()
 	msgBus.Close()
-	healthServer.Stop(context.Background())
+	channelManager.StopAll(ctx)
 	deviceService.Stop()
 	heartbeatService.Stop()
 	cronService.Stop()
 	agentLoop.Stop()
-	channelManager.StopAll(ctx)
 	fmt.Println("✓ Gateway stopped")
 }
 
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index fd06334d5..6ae048468 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -44,7 +44,6 @@ type replyTokenEntry struct {
 type LINEChannel struct {
 	*channels.BaseChannel
 	config         config.LINEConfig
-	httpServer     *http.Server
 	botUserID      string   // Bot's user ID
 	botBasicID     string   // Bot's basic ID (e.g. @216ru...)
 	botDisplayName string   // Bot's display name for text-based mention detection
@@ -68,7 +67,7 @@ func NewLINEChannel(cfg config.LINEConfig, messageBus *bus.MessageBus) (*LINECha
 	}, nil
 }
 
-// Start launches the HTTP webhook server.
+// Start initializes the LINE channel.
 func (c *LINEChannel) Start(ctx context.Context) error {
 	logger.InfoC("line", "Starting LINE channel (Webhook Mode)")
 
@@ -87,31 +86,6 @@ func (c *LINEChannel) Start(ctx context.Context) error {
 		})
 	}
 
-	mux := http.NewServeMux()
-	path := c.config.WebhookPath
-	if path == "" {
-		path = "/webhook/line"
-	}
-	mux.HandleFunc(path, c.webhookHandler)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.httpServer = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
-	go func() {
-		logger.InfoCF("line", "LINE webhook server listening", map[string]any{
-			"addr": addr,
-			"path": path,
-		})
-		if err := c.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("line", "Webhook server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
-
 	c.SetRunning(true)
 	logger.InfoC("line", "LINE channel started (Webhook Mode)")
 	return nil
@@ -151,7 +125,7 @@ func (c *LINEChannel) fetchBotInfo() error {
 	return nil
 }
 
-// Stop gracefully shuts down the HTTP server.
+// Stop gracefully stops the LINE channel.
 func (c *LINEChannel) Stop(ctx context.Context) error {
 	logger.InfoC("line", "Stopping LINE channel")
 
@@ -159,21 +133,24 @@ func (c *LINEChannel) Stop(ctx context.Context) error {
 		c.cancel()
 	}
 
-	if c.httpServer != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		if err := c.httpServer.Shutdown(shutdownCtx); err != nil {
-			logger.ErrorCF("line", "Webhook server shutdown error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}
-
 	c.SetRunning(false)
 	logger.InfoC("line", "LINE channel stopped")
 	return nil
 }
 
+// WebhookPath returns the path for registering on the shared HTTP server.
+func (c *LINEChannel) WebhookPath() string {
+	if c.config.WebhookPath != "" {
+		return c.config.WebhookPath
+	}
+	return "/webhook/line"
+}
+
+// ServeHTTP implements http.Handler for the shared HTTP server.
+func (c *LINEChannel) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c.webhookHandler(w, r)
+}
+
 // webhookHandler handles incoming LINE webhook requests.
 func (c *LINEChannel) webhookHandler(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 1bc321cec..dadc068e9 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"math"
+	"net/http"
 	"sync"
 	"time"
 
@@ -19,6 +20,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/constants"
+	"github.com/sipeed/picoclaw/pkg/health"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -55,6 +57,8 @@ type Manager struct {
 	config       *config.Config
 	mediaStore   media.MediaStore
 	dispatchTask *asyncTask
+	mux          *http.ServeMux
+	httpServer   *http.Server
 	mu           sync.RWMutex
 }
 
@@ -169,6 +173,43 @@ func (m *Manager) initChannels() error {
 	return nil
 }
 
+// SetupHTTPServer creates a shared HTTP server with the given listen address.
+// It registers health endpoints from the health server and discovers channels
+// that implement WebhookHandler and/or HealthChecker to register their handlers.
+func (m *Manager) SetupHTTPServer(addr string, healthServer *health.Server) {
+	m.mux = http.NewServeMux()
+
+	// Register health endpoints
+	if healthServer != nil {
+		healthServer.RegisterOnMux(m.mux)
+	}
+
+	// Discover and register webhook handlers and health checkers
+	for name, ch := range m.channels {
+		if wh, ok := ch.(WebhookHandler); ok {
+			m.mux.Handle(wh.WebhookPath(), wh)
+			logger.InfoCF("channels", "Webhook handler registered", map[string]any{
+				"channel": name,
+				"path":    wh.WebhookPath(),
+			})
+		}
+		if hc, ok := ch.(HealthChecker); ok {
+			m.mux.HandleFunc(hc.HealthPath(), hc.HealthHandler)
+			logger.InfoCF("channels", "Health endpoint registered", map[string]any{
+				"channel": name,
+				"path":    hc.HealthPath(),
+			})
+		}
+	}
+
+	m.httpServer = &http.Server{
+		Addr:         addr,
+		Handler:      m.mux,
+		ReadTimeout:  30 * time.Second,
+		WriteTimeout: 30 * time.Second,
+	}
+}
+
 func (m *Manager) StartAll(ctx context.Context) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -203,6 +244,20 @@ func (m *Manager) StartAll(ctx context.Context) error {
 	// Start the dispatcher that reads from the bus and routes to workers
 	go m.dispatchOutbound(dispatchCtx)
 
+	// Start shared HTTP server if configured
+	if m.httpServer != nil {
+		go func() {
+			logger.InfoCF("channels", "Shared HTTP server listening", map[string]any{
+				"addr": m.httpServer.Addr,
+			})
+			if err := m.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+				logger.ErrorCF("channels", "Shared HTTP server error", map[string]any{
+					"error": err.Error(),
+				})
+			}
+		}()
+	}
+
 	logger.InfoC("channels", "All channels started")
 	return nil
 }
@@ -213,7 +268,19 @@ func (m *Manager) StopAll(ctx context.Context) error {
 
 	logger.InfoC("channels", "Stopping all channels")
 
-	// Cancel dispatcher first
+	// Shutdown shared HTTP server first
+	if m.httpServer != nil {
+		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+		if err := m.httpServer.Shutdown(shutdownCtx); err != nil {
+			logger.ErrorCF("channels", "Shared HTTP server shutdown error", map[string]any{
+				"error": err.Error(),
+			})
+		}
+		m.httpServer = nil
+	}
+
+	// Cancel dispatcher
 	if m.dispatchTask != nil {
 		m.dispatchTask.cancel()
 		m.dispatchTask = nil
diff --git a/pkg/channels/webhook.go b/pkg/channels/webhook.go
new file mode 100644
index 000000000..3cf27baf6
--- /dev/null
+++ b/pkg/channels/webhook.go
@@ -0,0 +1,20 @@
+package channels
+
+import "net/http"
+
+// WebhookHandler is an optional interface for channels that receive messages
+// via HTTP webhooks. Manager discovers channels implementing this interface
+// and registers them on the shared HTTP server.
+type WebhookHandler interface {
+	// WebhookPath returns the path to mount this handler on the shared server.
+	// Examples: "/webhook/line", "/webhook/wecom"
+	WebhookPath() string
+	http.Handler // ServeHTTP(w http.ResponseWriter, r *http.Request)
+}
+
+// HealthChecker is an optional interface for channels that expose
+// a health check endpoint on the shared HTTP server.
+type HealthChecker interface {
+	HealthPath() string
+	HealthHandler(w http.ResponseWriter, r *http.Request)
+}
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 41861e8fc..52750505c 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -28,7 +28,6 @@ const (
 type WeComAppChannel struct {
 	*channels.BaseChannel
 	config        config.WeComAppConfig
-	server        *http.Server
 	accessToken   string
 	tokenExpiry   time.Time
 	tokenMu       sync.RWMutex
@@ -134,7 +133,7 @@ func (c *WeComAppChannel) Name() string {
 	return "wecom_app"
 }
 
-// Start initializes the WeCom App channel with HTTP webhook server
+// Start initializes the WeCom App channel
 func (c *WeComAppChannel) Start(ctx context.Context) error {
 	logger.InfoC("wecom_app", "Starting WeCom App channel...")
 
@@ -150,37 +149,8 @@ func (c *WeComAppChannel) Start(ctx context.Context) error {
 	// Start token refresh goroutine
 	go c.tokenRefreshLoop()
 
-	// Setup HTTP server for webhook
-	mux := http.NewServeMux()
-	webhookPath := c.config.WebhookPath
-	if webhookPath == "" {
-		webhookPath = "/webhook/wecom-app"
-	}
-	mux.HandleFunc(webhookPath, c.handleWebhook)
-
-	// Health check endpoint
-	mux.HandleFunc("/health/wecom-app", c.handleHealth)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.server = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
 	c.SetRunning(true)
-	logger.InfoCF("wecom_app", "WeCom App channel started", map[string]any{
-		"address": addr,
-		"path":    webhookPath,
-	})
-
-	// Start server in goroutine
-	go func() {
-		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom_app", "HTTP server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
+	logger.InfoC("wecom_app", "WeCom App channel started")
 
 	return nil
 }
@@ -193,12 +163,6 @@ func (c *WeComAppChannel) Stop(ctx context.Context) error {
 		c.cancel()
 	}
 
-	if c.server != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		c.server.Shutdown(shutdownCtx)
-	}
-
 	c.SetRunning(false)
 	logger.InfoC("wecom_app", "WeCom App channel stopped")
 	return nil
@@ -223,6 +187,29 @@ func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return c.sendTextMessage(ctx, accessToken, msg.ChatID, msg.Content)
 }
 
+// WebhookPath returns the path for registering on the shared HTTP server.
+func (c *WeComAppChannel) WebhookPath() string {
+	if c.config.WebhookPath != "" {
+		return c.config.WebhookPath
+	}
+	return "/webhook/wecom-app"
+}
+
+// ServeHTTP implements http.Handler for the shared HTTP server.
+func (c *WeComAppChannel) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c.handleWebhook(w, r)
+}
+
+// HealthPath returns the health check endpoint path.
+func (c *WeComAppChannel) HealthPath() string {
+	return "/health/wecom-app"
+}
+
+// HealthHandler handles health check requests.
+func (c *WeComAppChannel) HealthHandler(w http.ResponseWriter, r *http.Request) {
+	c.handleHealth(w, r)
+}
+
 // handleWebhook handles incoming webhook requests from WeCom
 func (c *WeComAppChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 7960802fb..d5912bddc 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -24,7 +24,6 @@ import (
 type WeComBotChannel struct {
 	*channels.BaseChannel
 	config        config.WeComConfig
-	server        *http.Server
 	ctx           context.Context
 	cancel        context.CancelFunc
 	processedMsgs map[string]bool // Message deduplication: msg_id -> processed
@@ -101,43 +100,14 @@ func (c *WeComBotChannel) Name() string {
 	return "wecom"
 }
 
-// Start initializes the WeCom Bot channel with HTTP webhook server
+// Start initializes the WeCom Bot channel
 func (c *WeComBotChannel) Start(ctx context.Context) error {
 	logger.InfoC("wecom", "Starting WeCom Bot channel...")
 
 	c.ctx, c.cancel = context.WithCancel(ctx)
 
-	// Setup HTTP server for webhook
-	mux := http.NewServeMux()
-	webhookPath := c.config.WebhookPath
-	if webhookPath == "" {
-		webhookPath = "/webhook/wecom"
-	}
-	mux.HandleFunc(webhookPath, c.handleWebhook)
-
-	// Health check endpoint
-	mux.HandleFunc("/health/wecom", c.handleHealth)
-
-	addr := fmt.Sprintf("%s:%d", c.config.WebhookHost, c.config.WebhookPort)
-	c.server = &http.Server{
-		Addr:    addr,
-		Handler: mux,
-	}
-
 	c.SetRunning(true)
-	logger.InfoCF("wecom", "WeCom Bot channel started", map[string]any{
-		"address": addr,
-		"path":    webhookPath,
-	})
-
-	// Start server in goroutine
-	go func() {
-		if err := c.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.ErrorCF("wecom", "HTTP server error", map[string]any{
-				"error": err.Error(),
-			})
-		}
-	}()
+	logger.InfoC("wecom", "WeCom Bot channel started")
 
 	return nil
 }
@@ -150,12 +120,6 @@ func (c *WeComBotChannel) Stop(ctx context.Context) error {
 		c.cancel()
 	}
 
-	if c.server != nil {
-		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-		defer cancel()
-		c.server.Shutdown(shutdownCtx)
-	}
-
 	c.SetRunning(false)
 	logger.InfoC("wecom", "WeCom Bot channel stopped")
 	return nil
@@ -177,6 +141,29 @@ func (c *WeComBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return c.sendWebhookReply(ctx, msg.ChatID, msg.Content)
 }
 
+// WebhookPath returns the path for registering on the shared HTTP server.
+func (c *WeComBotChannel) WebhookPath() string {
+	if c.config.WebhookPath != "" {
+		return c.config.WebhookPath
+	}
+	return "/webhook/wecom"
+}
+
+// ServeHTTP implements http.Handler for the shared HTTP server.
+func (c *WeComBotChannel) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c.handleWebhook(w, r)
+}
+
+// HealthPath returns the health check endpoint path.
+func (c *WeComBotChannel) HealthPath() string {
+	return "/health/wecom"
+}
+
+// HealthHandler handles health check requests.
+func (c *WeComBotChannel) HealthHandler(w http.ResponseWriter, r *http.Request) {
+	c.handleHealth(w, r)
+}
+
 // handleWebhook handles incoming webhook requests from WeCom
 func (c *WeComBotChannel) handleWebhook(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
diff --git a/pkg/health/server.go b/pkg/health/server.go
index 77b36034d..de1ff60fe 100644
--- a/pkg/health/server.go
+++ b/pkg/health/server.go
@@ -156,6 +156,13 @@ func (s *Server) readyHandler(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
+// RegisterOnMux registers /health and /ready handlers onto the given mux.
+// This allows the health endpoints to be served by a shared HTTP server.
+func (s *Server) RegisterOnMux(mux *http.ServeMux) {
+	mux.HandleFunc("/health", s.healthHandler)
+	mux.HandleFunc("/ready", s.readyHandler)
+}
+
 func statusString(ok bool) string {
 	if ok {
 		return "ok"

From 4c7a5df307627d94e69fa9477ca75844b35f51dc Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 03:10:57 +0800
Subject: [PATCH 42/52] feat(channels): add MediaSender optional interface for
 outbound media

Add outbound media sending capability so the agent can publish media
attachments (images, files, audio, video) through channels via the bus.

- Add MediaPart and OutboundMediaMessage types to bus
- Add PublishOutboundMedia/SubscribeOutboundMedia bus methods
- Add MediaSender interface discovered via type assertion by Manager
- Add media dispatch/worker in Manager with shared retry logic
- Extend ToolResult with Media field and MediaResult constructor
- Publish outbound media from agent loop on tool results
- Implement SendMedia for Telegram, Discord, Slack, LINE, OneBot, WeCom
---
 pkg/agent/loop.go                 |  13 ++
 pkg/bus/bus.go                    |  41 +++++--
 pkg/bus/types.go                  |  16 +++
 pkg/channels/discord/discord.go   |  98 +++++++++++++++
 pkg/channels/line/line.go         |  30 +++++
 pkg/channels/manager.go           | 150 +++++++++++++++++++++--
 pkg/channels/media.go             |  15 +++
 pkg/channels/onebot/onebot.go     | 111 +++++++++++++++++
 pkg/channels/slack/slack.go       |  54 +++++++++
 pkg/channels/telegram/telegram.go |  85 +++++++++++++
 pkg/channels/wecom/app.go         | 194 ++++++++++++++++++++++++++++++
 pkg/tools/result.go               |  17 +++
 12 files changed, 809 insertions(+), 15 deletions(-)
 create mode 100644 pkg/channels/media.go

diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index e243a6fdb..050303101 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -727,6 +727,19 @@ func (al *AgentLoop) runLLMIteration(
 					})
 			}
 
+			// If tool returned media refs, publish them as outbound media
+			if len(toolResult.Media) > 0 && opts.SendResponse {
+				parts := make([]bus.MediaPart, 0, len(toolResult.Media))
+				for _, ref := range toolResult.Media {
+					parts = append(parts, bus.MediaPart{Ref: ref})
+				}
+				al.bus.PublishOutboundMedia(ctx, bus.OutboundMediaMessage{
+					Channel: opts.Channel,
+					ChatID:  opts.ChatID,
+					Parts:   parts,
+				})
+			}
+
 			// Determine content for LLM based on tool result
 			contentForLLM := toolResult.ForLLM
 			if contentForLLM == "" && toolResult.Err != nil {
diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go
index 100ddc456..6a1c987b7 100644
--- a/pkg/bus/bus.go
+++ b/pkg/bus/bus.go
@@ -10,17 +10,19 @@ import (
 var ErrBusClosed = errors.New("message bus closed")
 
 type MessageBus struct {
-	inbound  chan InboundMessage
-	outbound chan OutboundMessage
-	done     chan struct{}
-	closed   atomic.Bool
+	inbound       chan InboundMessage
+	outbound      chan OutboundMessage
+	outboundMedia chan OutboundMediaMessage
+	done          chan struct{}
+	closed        atomic.Bool
 }
 
 func NewMessageBus() *MessageBus {
 	return &MessageBus{
-		inbound:  make(chan InboundMessage, 100),
-		outbound: make(chan OutboundMessage, 100),
-		done:     make(chan struct{}),
+		inbound:       make(chan InboundMessage, 100),
+		outbound:      make(chan OutboundMessage, 100),
+		outboundMedia: make(chan OutboundMediaMessage, 100),
+		done:          make(chan struct{}),
 	}
 }
 
@@ -74,6 +76,31 @@ func (mb *MessageBus) SubscribeOutbound(ctx context.Context) (OutboundMessage, b
 	}
 }
 
+func (mb *MessageBus) PublishOutboundMedia(ctx context.Context, msg OutboundMediaMessage) error {
+	if mb.closed.Load() {
+		return ErrBusClosed
+	}
+	select {
+	case mb.outboundMedia <- msg:
+		return nil
+	case <-mb.done:
+		return ErrBusClosed
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+func (mb *MessageBus) SubscribeOutboundMedia(ctx context.Context) (OutboundMediaMessage, bool) {
+	select {
+	case msg, ok := <-mb.outboundMedia:
+		return msg, ok
+	case <-mb.done:
+		return OutboundMediaMessage{}, false
+	case <-ctx.Done():
+		return OutboundMediaMessage{}, false
+	}
+}
+
 func (mb *MessageBus) Close() {
 	if mb.closed.CompareAndSwap(false, true) {
 		close(mb.done)
diff --git a/pkg/bus/types.go b/pkg/bus/types.go
index 358829c55..1a7a14170 100644
--- a/pkg/bus/types.go
+++ b/pkg/bus/types.go
@@ -24,3 +24,19 @@ type OutboundMessage struct {
 	ChatID  string `json:"chat_id"`
 	Content string `json:"content"`
 }
+
+// MediaPart describes a single media attachment to send.
+type MediaPart struct {
+	Type        string `json:"type"`                   // "image" | "audio" | "video" | "file"
+	Ref         string `json:"ref"`                    // media store ref, e.g. "media://abc123"
+	Caption     string `json:"caption,omitempty"`      // optional caption text
+	Filename    string `json:"filename,omitempty"`     // original filename hint
+	ContentType string `json:"content_type,omitempty"` // MIME type hint
+}
+
+// OutboundMediaMessage carries media attachments from Agent to channels via the bus.
+type OutboundMediaMessage struct {
+	Channel string      `json:"channel"`
+	ChatID  string      `json:"chat_id"`
+	Parts   []MediaPart `json:"parts"`
+}
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index d5524f7f9..7987f45a9 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -3,6 +3,7 @@ package discord
 import (
 	"context"
 	"fmt"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -128,6 +129,103 @@ func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 	return c.sendChunk(ctx, channelID, msg.Content)
 }
 
+// SendMedia implements the channels.MediaSender interface.
+func (c *DiscordChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	c.stopTyping(msg.ChatID)
+
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	channelID := msg.ChatID
+	if channelID == "" {
+		return fmt.Errorf("channel ID is empty")
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	// Collect all files into a single ChannelMessageSendComplex call
+	files := make([]*discordgo.File, 0, len(msg.Parts))
+	var caption string
+
+	for _, part := range msg.Parts {
+		localPath, err := store.Resolve(part.Ref)
+		if err != nil {
+			logger.ErrorCF("discord", "Failed to resolve media ref", map[string]any{
+				"ref":   part.Ref,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		file, err := os.Open(localPath)
+		if err != nil {
+			logger.ErrorCF("discord", "Failed to open media file", map[string]any{
+				"path":  localPath,
+				"error": err.Error(),
+			})
+			continue
+		}
+		// Note: discordgo reads from the Reader and we can't close it before send
+
+		filename := part.Filename
+		if filename == "" {
+			filename = "file"
+		}
+
+		files = append(files, &discordgo.File{
+			Name:        filename,
+			ContentType: part.ContentType,
+			Reader:      file,
+		})
+
+		if part.Caption != "" && caption == "" {
+			caption = part.Caption
+		}
+	}
+
+	if len(files) == 0 {
+		return nil
+	}
+
+	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
+	defer cancel()
+
+	done := make(chan error, 1)
+	go func() {
+		_, err := c.session.ChannelMessageSendComplex(channelID, &discordgo.MessageSend{
+			Content: caption,
+			Files:   files,
+		})
+		done <- err
+	}()
+
+	select {
+	case err := <-done:
+		// Close all file readers
+		for _, f := range files {
+			if closer, ok := f.Reader.(*os.File); ok {
+				closer.Close()
+			}
+		}
+		if err != nil {
+			return fmt.Errorf("discord send media: %w", channels.ErrTemporary)
+		}
+		return nil
+	case <-sendCtx.Done():
+		// Close all file readers
+		for _, f := range files {
+			if closer, ok := f.Reader.(*os.File); ok {
+				closer.Close()
+			}
+		}
+		return sendCtx.Err()
+	}
+}
+
 func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
 	// Use the passed ctx for timeout control
 	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 6ae048468..5b0af4f1d 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -496,6 +496,36 @@ func (c *LINEChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	return c.sendPush(ctx, msg.ChatID, msg.Content, quoteToken)
 }
 
+// SendMedia implements the channels.MediaSender interface.
+// LINE requires media to be accessible via public URL; since we only have local files,
+// we fall back to sending a text message with the filename/caption.
+// For full support, an external file hosting service would be needed.
+func (c *LINEChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	// LINE Messaging API requires publicly accessible URLs for media messages.
+	// Since we only have local file paths, send caption text as fallback.
+	for _, part := range msg.Parts {
+		caption := part.Caption
+		if caption == "" {
+			caption = fmt.Sprintf("[%s: %s]", part.Type, part.Filename)
+		}
+
+		if err := c.sendPush(ctx, msg.ChatID, caption, ""); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // buildTextMessage creates a text message object, optionally with quoteToken.
 func buildTextMessage(content, quoteToken string) map[string]string {
 	msg := map[string]string{
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index dadc068e9..92412edeb 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -44,10 +44,12 @@ var channelRateConfig = map[string]float64{
 }
 
 type channelWorker struct {
-	ch      Channel
-	queue   chan bus.OutboundMessage
-	done    chan struct{}
-	limiter *rate.Limiter
+	ch         Channel
+	queue      chan bus.OutboundMessage
+	mediaQueue chan bus.OutboundMediaMessage
+	done       chan struct{}
+	mediaDone  chan struct{}
+	limiter    *rate.Limiter
 }
 
 type Manager struct {
@@ -239,10 +241,12 @@ func (m *Manager) StartAll(ctx context.Context) error {
 	// Start per-channel workers
 	for name, w := range m.workers {
 		go m.runWorker(dispatchCtx, name, w)
+		go m.runMediaWorker(dispatchCtx, name, w)
 	}
 
 	// Start the dispatcher that reads from the bus and routes to workers
 	go m.dispatchOutbound(dispatchCtx)
+	go m.dispatchOutboundMedia(dispatchCtx)
 
 	// Start shared HTTP server if configured
 	if m.httpServer != nil {
@@ -293,6 +297,13 @@ func (m *Manager) StopAll(ctx context.Context) error {
 	for _, w := range m.workers {
 		<-w.done
 	}
+	// Close all media worker queues and wait for them to drain
+	for _, w := range m.workers {
+		close(w.mediaQueue)
+	}
+	for _, w := range m.workers {
+		<-w.mediaDone
+	}
 
 	// Stop all channels
 	for name, channel := range m.channels {
@@ -321,10 +332,12 @@ func newChannelWorker(name string, ch Channel) *channelWorker {
 	burst := int(math.Max(1, math.Ceil(rateVal/2)))
 
 	return &channelWorker{
-		ch:      ch,
-		queue:   make(chan bus.OutboundMessage, defaultChannelQueueSize),
-		done:    make(chan struct{}),
-		limiter: rate.NewLimiter(rate.Limit(rateVal), burst),
+		ch:         ch,
+		queue:      make(chan bus.OutboundMessage, defaultChannelQueueSize),
+		mediaQueue: make(chan bus.OutboundMediaMessage, defaultChannelQueueSize),
+		done:       make(chan struct{}),
+		mediaDone:  make(chan struct{}),
+		limiter:    rate.NewLimiter(rate.Limit(rateVal), burst),
 	}
 }
 
@@ -457,6 +470,125 @@ func (m *Manager) dispatchOutbound(ctx context.Context) {
 	}
 }
 
+func (m *Manager) dispatchOutboundMedia(ctx context.Context) {
+	logger.InfoC("channels", "Outbound media dispatcher started")
+
+	for {
+		select {
+		case <-ctx.Done():
+			logger.InfoC("channels", "Outbound media dispatcher stopped")
+			return
+		default:
+			msg, ok := m.bus.SubscribeOutboundMedia(ctx)
+			if !ok {
+				continue
+			}
+
+			// Silently skip internal channels
+			if constants.IsInternalChannel(msg.Channel) {
+				continue
+			}
+
+			m.mu.RLock()
+			_, exists := m.channels[msg.Channel]
+			w, wExists := m.workers[msg.Channel]
+			m.mu.RUnlock()
+
+			if !exists {
+				logger.WarnCF("channels", "Unknown channel for outbound media message", map[string]any{
+					"channel": msg.Channel,
+				})
+				continue
+			}
+
+			if wExists {
+				select {
+				case w.mediaQueue <- msg:
+				case <-ctx.Done():
+					return
+				}
+			}
+		}
+	}
+}
+
+// runMediaWorker processes outbound media messages for a single channel.
+func (m *Manager) runMediaWorker(ctx context.Context, name string, w *channelWorker) {
+	defer close(w.mediaDone)
+	for {
+		select {
+		case msg, ok := <-w.mediaQueue:
+			if !ok {
+				return
+			}
+			m.sendMediaWithRetry(ctx, name, w, msg)
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// sendMediaWithRetry sends a media message through the channel with rate limiting and
+// retry logic. If the channel does not implement MediaSender, it silently skips.
+func (m *Manager) sendMediaWithRetry(ctx context.Context, name string, w *channelWorker, msg bus.OutboundMediaMessage) {
+	ms, ok := w.ch.(MediaSender)
+	if !ok {
+		logger.DebugCF("channels", "Channel does not support MediaSender, skipping media", map[string]any{
+			"channel": name,
+		})
+		return
+	}
+
+	// Rate limit: wait for token
+	if err := w.limiter.Wait(ctx); err != nil {
+		return
+	}
+
+	var lastErr error
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		lastErr = ms.SendMedia(ctx, msg)
+		if lastErr == nil {
+			return
+		}
+
+		// Permanent failures — don't retry
+		if errors.Is(lastErr, ErrNotRunning) || errors.Is(lastErr, ErrSendFailed) {
+			break
+		}
+
+		// Last attempt exhausted — don't sleep
+		if attempt == maxRetries {
+			break
+		}
+
+		// Rate limit error — fixed delay
+		if errors.Is(lastErr, ErrRateLimit) {
+			select {
+			case <-time.After(rateLimitDelay):
+				continue
+			case <-ctx.Done():
+				return
+			}
+		}
+
+		// ErrTemporary or unknown error — exponential backoff
+		backoff := min(time.Duration(float64(baseBackoff)*math.Pow(2, float64(attempt))), maxBackoff)
+		select {
+		case <-time.After(backoff):
+		case <-ctx.Done():
+			return
+		}
+	}
+
+	// All retries exhausted or permanent failure
+	logger.ErrorCF("channels", "SendMedia failed", map[string]any{
+		"channel": name,
+		"chat_id": msg.ChatID,
+		"error":   lastErr.Error(),
+		"retries": maxRetries,
+	})
+}
+
 func (m *Manager) GetChannel(name string) (Channel, bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -502,6 +634,8 @@ func (m *Manager) UnregisterChannel(name string) {
 	if w, ok := m.workers[name]; ok {
 		close(w.queue)
 		<-w.done
+		close(w.mediaQueue)
+		<-w.mediaDone
 	}
 	delete(m.workers, name)
 	delete(m.channels, name)
diff --git a/pkg/channels/media.go b/pkg/channels/media.go
new file mode 100644
index 000000000..c645a6180
--- /dev/null
+++ b/pkg/channels/media.go
@@ -0,0 +1,15 @@
+package channels
+
+import (
+	"context"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+)
+
+// MediaSender is an optional interface for channels that can send
+// media attachments (images, files, audio, video).
+// Manager discovers channels implementing this interface via type
+// assertion and routes OutboundMediaMessage to them.
+type MediaSender interface {
+	SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error
+}
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 76950663e..fb357cf27 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -431,6 +431,117 @@ func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 	return nil
 }
 
+// SendMedia implements the channels.MediaSender interface.
+func (c *OneBotChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
+	c.mu.Lock()
+	conn := c.conn
+	c.mu.Unlock()
+
+	if conn == nil {
+		return fmt.Errorf("OneBot WebSocket not connected")
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	// Build media segments
+	var segments []oneBotMessageSegment
+	for _, part := range msg.Parts {
+		localPath, err := store.Resolve(part.Ref)
+		if err != nil {
+			logger.ErrorCF("onebot", "Failed to resolve media ref", map[string]any{
+				"ref":   part.Ref,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		segType := "image"
+		switch part.Type {
+		case "image":
+			segType = "image"
+		case "video":
+			segType = "video"
+		case "audio":
+			segType = "record"
+		default:
+			segType = "file"
+		}
+
+		segments = append(segments, oneBotMessageSegment{
+			Type: segType,
+			Data: map[string]any{"file": "file://" + localPath},
+		})
+
+		if part.Caption != "" {
+			segments = append(segments, oneBotMessageSegment{
+				Type: "text",
+				Data: map[string]any{"text": part.Caption},
+			})
+		}
+	}
+
+	if len(segments) == 0 {
+		return nil
+	}
+
+	chatID := msg.ChatID
+	var action, idKey string
+	var rawID string
+	if rest, ok := strings.CutPrefix(chatID, "group:"); ok {
+		action, idKey, rawID = "send_group_msg", "group_id", rest
+	} else if rest, ok := strings.CutPrefix(chatID, "private:"); ok {
+		action, idKey, rawID = "send_private_msg", "user_id", rest
+	} else {
+		action, idKey, rawID = "send_private_msg", "user_id", chatID
+	}
+
+	id, err := strconv.ParseInt(rawID, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid %s in chatID: %s: %w", idKey, chatID, channels.ErrSendFailed)
+	}
+
+	echo := fmt.Sprintf("send_%d", atomic.AddInt64(&c.echoCounter, 1))
+
+	req := oneBotAPIRequest{
+		Action: action,
+		Params: map[string]any{idKey: id, "message": segments},
+		Echo:   echo,
+	}
+
+	data, err := json.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("failed to marshal OneBot request: %w", err)
+	}
+
+	c.writeMu.Lock()
+	_ = conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
+	err = conn.WriteMessage(websocket.TextMessage, data)
+	_ = conn.SetWriteDeadline(time.Time{})
+	c.writeMu.Unlock()
+
+	if err != nil {
+		logger.ErrorCF("onebot", "Failed to send media message", map[string]any{
+			"error": err.Error(),
+		})
+		return fmt.Errorf("onebot send media: %w", channels.ErrTemporary)
+	}
+
+	return nil
+}
+
 func (c *OneBotChannel) buildMessageSegments(chatID, content string) []oneBotMessageSegment {
 	var segments []oneBotMessageSegment
 
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index 9e066e00a..f2dda15ac 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -149,6 +149,60 @@ func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 	return nil
 }
 
+// SendMedia implements the channels.MediaSender interface.
+func (c *SlackChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	channelID, _ := parseSlackChatID(msg.ChatID)
+	if channelID == "" {
+		return fmt.Errorf("invalid slack chat ID: %s", msg.ChatID)
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	for _, part := range msg.Parts {
+		localPath, err := store.Resolve(part.Ref)
+		if err != nil {
+			logger.ErrorCF("slack", "Failed to resolve media ref", map[string]any{
+				"ref":   part.Ref,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		filename := part.Filename
+		if filename == "" {
+			filename = "file"
+		}
+
+		title := part.Caption
+		if title == "" {
+			title = filename
+		}
+
+		_, err = c.api.UploadFileV2Context(ctx, slack.UploadFileV2Parameters{
+			Channel:  channelID,
+			File:     localPath,
+			Filename: filename,
+			Title:    title,
+		})
+		if err != nil {
+			logger.ErrorCF("slack", "Failed to upload media", map[string]any{
+				"filename": filename,
+				"error":    err.Error(),
+			})
+			return fmt.Errorf("slack send media: %w", channels.ErrTemporary)
+		}
+	}
+
+	return nil
+}
+
 func (c *SlackChannel) eventLoop() {
 	for {
 		select {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index a07eb6579..f9390b8ed 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -231,6 +231,91 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return nil
 }
 
+// SendMedia implements the channels.MediaSender interface.
+func (c *TelegramChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	chatID, err := parseChatID(msg.ChatID)
+	if err != nil {
+		return fmt.Errorf("invalid chat ID %s: %w", msg.ChatID, channels.ErrSendFailed)
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	for _, part := range msg.Parts {
+		localPath, err := store.Resolve(part.Ref)
+		if err != nil {
+			logger.ErrorCF("telegram", "Failed to resolve media ref", map[string]any{
+				"ref":   part.Ref,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		file, err := os.Open(localPath)
+		if err != nil {
+			logger.ErrorCF("telegram", "Failed to open media file", map[string]any{
+				"path":  localPath,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		filename := part.Filename
+		if filename == "" {
+			filename = "file"
+		}
+
+		switch part.Type {
+		case "image":
+			params := &telego.SendPhotoParams{
+				ChatID:  tu.ID(chatID),
+				Photo:   telego.InputFile{File: file},
+				Caption: part.Caption,
+			}
+			_, err = c.bot.SendPhoto(ctx, params)
+		case "audio":
+			params := &telego.SendAudioParams{
+				ChatID:  tu.ID(chatID),
+				Audio:   telego.InputFile{File: file},
+				Caption: part.Caption,
+			}
+			_, err = c.bot.SendAudio(ctx, params)
+		case "video":
+			params := &telego.SendVideoParams{
+				ChatID:  tu.ID(chatID),
+				Video:   telego.InputFile{File: file},
+				Caption: part.Caption,
+			}
+			_, err = c.bot.SendVideo(ctx, params)
+		default: // "file" or unknown types
+			params := &telego.SendDocumentParams{
+				ChatID:   tu.ID(chatID),
+				Document: telego.InputFile{File: file},
+				Caption:  part.Caption,
+			}
+			_, err = c.bot.SendDocument(ctx, params)
+		}
+
+		file.Close()
+
+		if err != nil {
+			logger.ErrorCF("telegram", "Failed to send media", map[string]any{
+				"type":  part.Type,
+				"error": err.Error(),
+			})
+			return fmt.Errorf("telegram send media: %w", channels.ErrTemporary)
+		}
+	}
+
+	return nil
+}
+
 func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Message) error {
 	if message == nil {
 		return fmt.Errorf("message is nil")
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 52750505c..4c2a4d326 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -7,8 +7,11 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"mime/multipart"
 	"net/http"
 	"net/url"
+	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -187,6 +190,197 @@ func (c *WeComAppChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return c.sendTextMessage(ctx, accessToken, msg.ChatID, msg.Content)
 }
 
+// SendMedia implements the channels.MediaSender interface.
+func (c *WeComAppChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	accessToken := c.getAccessToken()
+	if accessToken == "" {
+		return fmt.Errorf("no valid access token available: %w", channels.ErrTemporary)
+	}
+
+	store := c.GetMediaStore()
+	if store == nil {
+		return fmt.Errorf("no media store available: %w", channels.ErrSendFailed)
+	}
+
+	for _, part := range msg.Parts {
+		localPath, err := store.Resolve(part.Ref)
+		if err != nil {
+			logger.ErrorCF("wecom_app", "Failed to resolve media ref", map[string]any{
+				"ref":   part.Ref,
+				"error": err.Error(),
+			})
+			continue
+		}
+
+		// Map part type to WeCom media type
+		mediaType := "file"
+		switch part.Type {
+		case "image":
+			mediaType = "image"
+		case "audio":
+			mediaType = "voice"
+		case "video":
+			mediaType = "video"
+		default:
+			mediaType = "file"
+		}
+
+		// Upload media to get media_id
+		mediaID, err := c.uploadMedia(ctx, accessToken, mediaType, localPath)
+		if err != nil {
+			logger.ErrorCF("wecom_app", "Failed to upload media", map[string]any{
+				"type":  mediaType,
+				"error": err.Error(),
+			})
+			// Fallback: send caption as text
+			if part.Caption != "" {
+				_ = c.sendTextMessage(ctx, accessToken, msg.ChatID, part.Caption)
+			}
+			continue
+		}
+
+		// Send media message using the media_id
+		if mediaType == "image" {
+			err = c.sendImageMessage(ctx, accessToken, msg.ChatID, mediaID)
+		} else {
+			// For non-image types, send as text fallback with caption
+			caption := part.Caption
+			if caption == "" {
+				caption = fmt.Sprintf("[%s: %s]", part.Type, part.Filename)
+			}
+			err = c.sendTextMessage(ctx, accessToken, msg.ChatID, caption)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// uploadMedia uploads a local file to WeCom temporary media storage.
+func (c *WeComAppChannel) uploadMedia(ctx context.Context, accessToken, mediaType, localPath string) (string, error) {
+	apiURL := fmt.Sprintf("%s/cgi-bin/media/upload?access_token=%s&type=%s",
+		wecomAPIBase, url.QueryEscape(accessToken), url.QueryEscape(mediaType))
+
+	file, err := os.Open(localPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	filename := filepath.Base(localPath)
+	formFile, err := writer.CreateFormFile("media", filename)
+	if err != nil {
+		return "", fmt.Errorf("failed to create form file: %w", err)
+	}
+
+	if _, err = io.Copy(formFile, file); err != nil {
+		return "", fmt.Errorf("failed to copy file content: %w", err)
+	}
+	writer.Close()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, body)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", channels.ClassifyNetError(err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return "", channels.ClassifySendError(resp.StatusCode, fmt.Errorf("wecom upload error: %s", string(respBody)))
+	}
+
+	var result struct {
+		ErrCode int    `json:"errcode"`
+		ErrMsg  string `json:"errmsg"`
+		MediaID string `json:"media_id"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("failed to parse upload response: %w", err)
+	}
+
+	if result.ErrCode != 0 {
+		return "", fmt.Errorf("upload API error: %s (code: %d)", result.ErrMsg, result.ErrCode)
+	}
+
+	return result.MediaID, nil
+}
+
+// sendImageMessage sends an image message using a media_id.
+func (c *WeComAppChannel) sendImageMessage(ctx context.Context, accessToken, userID, mediaID string) error {
+	apiURL := fmt.Sprintf("%s/cgi-bin/message/send?access_token=%s", wecomAPIBase, accessToken)
+
+	msg := WeComImageMessage{
+		ToUser:  userID,
+		MsgType: "image",
+		AgentID: c.config.AgentID,
+	}
+	msg.Image.MediaID = mediaID
+
+	jsonData, err := json.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %w", err)
+	}
+
+	timeout := c.config.ReplyTimeout
+	if timeout <= 0 {
+		timeout = 5
+	}
+
+	reqCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, apiURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return channels.ClassifyNetError(err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return channels.ClassifySendError(resp.StatusCode, fmt.Errorf("wecom_app API error: %s", string(respBody)))
+	}
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var sendResp WeComSendMessageResponse
+	if err := json.Unmarshal(respBody, &sendResp); err != nil {
+		return fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if sendResp.ErrCode != 0 {
+		return fmt.Errorf("API error: %s (code: %d)", sendResp.ErrMsg, sendResp.ErrCode)
+	}
+
+	return nil
+}
+
 // WebhookPath returns the path for registering on the shared HTTP server.
 func (c *WeComAppChannel) WebhookPath() string {
 	if c.config.WebhookPath != "" {
diff --git a/pkg/tools/result.go b/pkg/tools/result.go
index b13055b1c..cab833284 100644
--- a/pkg/tools/result.go
+++ b/pkg/tools/result.go
@@ -30,6 +30,10 @@ type ToolResult struct {
 	// Err is the underlying error (not JSON serialized).
 	// Used for internal error handling and logging.
 	Err error `json:"-"`
+
+	// Media contains media store refs produced by this tool.
+	// When non-empty, the agent will publish these as OutboundMediaMessage.
+	Media []string `json:"media,omitempty"`
 }
 
 // NewToolResult creates a basic ToolResult with content for the LLM.
@@ -120,6 +124,19 @@ func UserResult(content string) *ToolResult {
 	}
 }
 
+// MediaResult creates a ToolResult with media refs for the user.
+// The agent will publish these refs as OutboundMediaMessage.
+//
+// Example:
+//
+//	result := MediaResult("Image generated successfully", []string{"media://abc123"})
+func MediaResult(forLLM string, mediaRefs []string) *ToolResult {
+	return &ToolResult{
+		ForLLM: forLLM,
+		Media:  mediaRefs,
+	}
+}
+
 // MarshalJSON implements custom JSON serialization.
 // The Err field is excluded from JSON output via the json:"-" tag.
 func (tr *ToolResult) MarshalJSON() ([]byte, error) {

From 437657c5d55e1d249ce05b9662b22956e46c9d2b Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 03:47:12 +0800
Subject: [PATCH 43/52] refactor(channels): remove channel-side voice
 transcription (Phase 12)

Remove SetTranscriber and inline transcription logic from 4 channels
(Telegram, Discord, Slack, OneBot) and the gateway wiring. Voice/audio
files are still downloaded and stored in MediaStore with simple text
annotations ([voice], [audio: filename], [file: name]). The pkg/voice
package is preserved for future Agent-level transcription middleware.
---
 cmd/picoclaw/cmd_gateway.go       | 44 ++-------------------------
 pkg/channels/discord/discord.go   | 49 +++++++------------------------
 pkg/channels/onebot/onebot.go     | 27 ++---------------
 pkg/channels/slack/slack.go       | 23 +--------------
 pkg/channels/telegram/telegram.go | 31 +------------------
 5 files changed, 17 insertions(+), 157 deletions(-)

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 4e6ec8bb3..837c55f37 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -9,21 +9,20 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/sipeed/picoclaw/pkg/agent"
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	_ "github.com/sipeed/picoclaw/pkg/channels/dingtalk"
-	dch "github.com/sipeed/picoclaw/pkg/channels/discord"
+	_ "github.com/sipeed/picoclaw/pkg/channels/discord"
 	_ "github.com/sipeed/picoclaw/pkg/channels/feishu"
 	_ "github.com/sipeed/picoclaw/pkg/channels/line"
 	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
 	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
 	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
-	slackch "github.com/sipeed/picoclaw/pkg/channels/slack"
-	tgramch "github.com/sipeed/picoclaw/pkg/channels/telegram"
+	_ "github.com/sipeed/picoclaw/pkg/channels/slack"
+	_ "github.com/sipeed/picoclaw/pkg/channels/telegram"
 	_ "github.com/sipeed/picoclaw/pkg/channels/wecom"
 	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp"
 	"github.com/sipeed/picoclaw/pkg/config"
@@ -36,7 +35,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/providers"
 	"github.com/sipeed/picoclaw/pkg/state"
 	"github.com/sipeed/picoclaw/pkg/tools"
-	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
 func gatewayCmd() {
@@ -136,42 +134,6 @@ func gatewayCmd() {
 	agentLoop.SetChannelManager(channelManager)
 	agentLoop.SetMediaStore(mediaStore)
 
-	var transcriber *voice.GroqTranscriber
-	groqAPIKey := cfg.Providers.Groq.APIKey
-	if groqAPIKey == "" {
-		for _, mc := range cfg.ModelList {
-			if strings.HasPrefix(mc.Model, "groq/") && mc.APIKey != "" {
-				groqAPIKey = mc.APIKey
-				break
-			}
-		}
-	}
-	if groqAPIKey != "" {
-		transcriber = voice.NewGroqTranscriber(groqAPIKey)
-		logger.InfoC("voice", "Groq voice transcription enabled")
-	}
-
-	if transcriber != nil {
-		if telegramChannel, ok := channelManager.GetChannel("telegram"); ok {
-			if tc, ok := telegramChannel.(*tgramch.TelegramChannel); ok {
-				tc.SetTranscriber(transcriber)
-				logger.InfoC("voice", "Groq transcription attached to Telegram channel")
-			}
-		}
-		if discordChannel, ok := channelManager.GetChannel("discord"); ok {
-			if dc, ok := discordChannel.(*dch.DiscordChannel); ok {
-				dc.SetTranscriber(transcriber)
-				logger.InfoC("voice", "Groq transcription attached to Discord channel")
-			}
-		}
-		if slackChannel, ok := channelManager.GetChannel("slack"); ok {
-			if sc, ok := slackChannel.(*slackch.SlackChannel); ok {
-				sc.SetTranscriber(transcriber)
-				logger.InfoC("voice", "Groq transcription attached to Slack channel")
-			}
-		}
-	}
-
 	enabledChannels := channelManager.GetEnabledChannels()
 	if len(enabledChannels) > 0 {
 		fmt.Printf("✓ Channels enabled: %s\n", enabledChannels)
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 7987f45a9..68725b124 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -16,24 +16,21 @@ import (
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
 const (
-	transcriptionTimeout = 30 * time.Second
-	sendTimeout          = 10 * time.Second
+	sendTimeout = 10 * time.Second
 )
 
 type DiscordChannel struct {
 	*channels.BaseChannel
-	session     *discordgo.Session
-	config      config.DiscordConfig
-	transcriber *voice.GroqTranscriber
-	ctx         context.Context
-	cancel      context.CancelFunc
-	typingMu    sync.Mutex
-	typingStop  map[string]chan struct{} // chatID → stop signal
-	botUserID   string                   // stored for mention checking
+	session    *discordgo.Session
+	config     config.DiscordConfig
+	ctx        context.Context
+	cancel     context.CancelFunc
+	typingMu   sync.Mutex
+	typingStop map[string]chan struct{} // chatID → stop signal
+	botUserID  string                   // stored for mention checking
 }
 
 func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordChannel, error) {
@@ -48,16 +45,11 @@ func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordC
 		BaseChannel: base,
 		session:     session,
 		config:      cfg,
-		transcriber: nil,
 		ctx:         context.Background(),
 		typingStop:  make(map[string]chan struct{}),
 	}, nil
 }
 
-func (c *DiscordChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
 func (c *DiscordChannel) Start(ctx context.Context) error {
 	logger.InfoC("discord", "Starting Discord bot")
 
@@ -265,7 +257,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		return
 	}
 
-	// Check allowlist first to avoid downloading attachments and transcribing for rejected users
+	// Check allowlist first to avoid downloading attachments for rejected users
 	if !c.IsAllowed(m.Author.ID) {
 		logger.DebugCF("discord", "Message rejected by allowlist", map[string]any{
 			"user_id": m.Author.ID,
@@ -323,29 +315,8 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		if isAudio {
 			localPath := c.downloadAttachment(attachment.URL, attachment.Filename)
 			if localPath != "" {
-				transcribedText := ""
-				if c.transcriber != nil && c.transcriber.IsAvailable() {
-					ctx, cancel := context.WithTimeout(c.ctx, transcriptionTimeout)
-					result, err := c.transcriber.Transcribe(ctx, localPath)
-					cancel() // Release context resources immediately to avoid leaks in for loop
-
-					if err != nil {
-						logger.ErrorCF("discord", "Voice transcription failed", map[string]any{
-							"error": err.Error(),
-						})
-						transcribedText = fmt.Sprintf("[audio: %s (transcription failed)]", attachment.Filename)
-					} else {
-						transcribedText = fmt.Sprintf("[audio transcription: %s]", result.Text)
-						logger.DebugCF("discord", "Audio transcribed successfully", map[string]any{
-							"text": result.Text,
-						})
-					}
-				} else {
-					transcribedText = fmt.Sprintf("[audio: %s]", attachment.Filename)
-				}
-
 				mediaPaths = append(mediaPaths, storeMedia(localPath, attachment.Filename))
-				content = appendContent(content, transcribedText)
+				content = appendContent(content, fmt.Sprintf("[audio: %s]", attachment.Filename))
 			} else {
 				logger.WarnCF("discord", "Failed to download audio attachment", map[string]any{
 					"url":      attachment.URL,
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index fb357cf27..001965238 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -18,7 +18,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
 type OneBotChannel struct {
@@ -36,7 +35,6 @@ type OneBotChannel struct {
 	selfID          int64
 	pending         map[string]chan json.RawMessage
 	pendingMu       sync.Mutex
-	transcriber     *voice.GroqTranscriber
 	lastMessageID   sync.Map
 	pendingEmojiMsg sync.Map
 }
@@ -112,10 +110,6 @@ func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*One
 	}, nil
 }
 
-func (c *OneBotChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
 func (c *OneBotChannel) setMsgEmojiLike(messageID string, emojiID int, set bool) {
 	go func() {
 		_, err := c.sendAPIRequest("set_msg_emoji_like", map[string]any{
@@ -794,25 +788,8 @@ func (c *OneBotChannel) parseMessageSegments(
 						LoggerPrefix: "onebot",
 					})
 					if localPath != "" {
-						if c.transcriber != nil && c.transcriber.IsAvailable() {
-							tctx, tcancel := context.WithTimeout(c.ctx, 30*time.Second)
-							result, err := c.transcriber.Transcribe(tctx, localPath)
-							tcancel()
-							if err != nil {
-								logger.WarnCF("onebot", "Voice transcription failed", map[string]any{
-									"error": err.Error(),
-								})
-								textParts = append(textParts, "[voice (transcription failed)]")
-								mediaRefs = append(mediaRefs, storeFile(localPath, "voice.amr"))
-							} else {
-								textParts = append(textParts, fmt.Sprintf("[voice transcription: %s]", result.Text))
-								// Still store the file so it can be released later
-								storeFile(localPath, "voice.amr")
-							}
-						} else {
-							textParts = append(textParts, "[voice]")
-							mediaRefs = append(mediaRefs, storeFile(localPath, "voice.amr"))
-						}
+						textParts = append(textParts, "[voice]")
+						mediaRefs = append(mediaRefs, storeFile(localPath, "voice.amr"))
 					}
 				}
 			}
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index f2dda15ac..a8d329d65 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/slack-go/slack"
 	"github.com/slack-go/slack/slackevents"
@@ -17,7 +16,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
 type SlackChannel struct {
@@ -27,7 +25,6 @@ type SlackChannel struct {
 	socketClient *socketmode.Client
 	botUserID    string
 	teamID       string
-	transcriber  *voice.GroqTranscriber
 	ctx          context.Context
 	cancel       context.CancelFunc
 	pendingAcks  sync.Map
@@ -60,10 +57,6 @@ func NewSlackChannel(cfg config.SlackConfig, messageBus *bus.MessageBus) (*Slack
 	}, nil
 }
 
-func (c *SlackChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
 func (c *SlackChannel) Start(ctx context.Context) error {
 	logger.InfoC("slack", "Starting Slack channel (Socket Mode)")
 
@@ -311,21 +304,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 				continue
 			}
 			mediaPaths = append(mediaPaths, storeMedia(localPath, file.Name))
-
-			if utils.IsAudioFile(file.Name, file.Mimetype) && c.transcriber != nil && c.transcriber.IsAvailable() {
-				ctx, cancel := context.WithTimeout(c.ctx, 30*time.Second)
-				defer cancel()
-				result, err := c.transcriber.Transcribe(ctx, localPath)
-
-				if err != nil {
-					logger.ErrorCF("slack", "Voice transcription failed", map[string]any{"error": err.Error()})
-					content += fmt.Sprintf("\n[audio: %s (transcription failed)]", file.Name)
-				} else {
-					content += fmt.Sprintf("\n[voice transcription: %s]", result.Text)
-				}
-			} else {
-				content += fmt.Sprintf("\n[file: %s]", file.Name)
-			}
+			content += fmt.Sprintf("\n[file: %s]", file.Name)
 		}
 	}
 
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index f9390b8ed..9544987ec 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -22,7 +22,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
-	"github.com/sipeed/picoclaw/pkg/voice"
 )
 
 type TelegramChannel struct {
@@ -32,7 +31,6 @@ type TelegramChannel struct {
 	commands     TelegramCommander
 	config       *config.Config
 	chatIDs      map[string]int64
-	transcriber  *voice.GroqTranscriber
 	ctx          context.Context
 	cancel       context.CancelFunc
 	placeholders sync.Map // chatID -> messageID
@@ -91,16 +89,11 @@ func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChann
 		bot:          bot,
 		config:       cfg,
 		chatIDs:      make(map[string]int64),
-		transcriber:  nil,
 		placeholders: sync.Map{},
 		stopThinking: sync.Map{},
 	}, nil
 }
 
-func (c *TelegramChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
-	c.transcriber = transcriber
-}
-
 func (c *TelegramChannel) Start(ctx context.Context) error {
 	logger.InfoC("telegram", "Starting Telegram bot (polling mode)...")
 
@@ -391,32 +384,10 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		if voicePath != "" {
 			mediaPaths = append(mediaPaths, storeMedia(voicePath, "voice.ogg"))
 
-			transcribedText := ""
-			if c.transcriber != nil && c.transcriber.IsAvailable() {
-				transcriberCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
-				defer cancel()
-
-				result, err := c.transcriber.Transcribe(transcriberCtx, voicePath)
-				if err != nil {
-					logger.ErrorCF("telegram", "Voice transcription failed", map[string]any{
-						"error": err.Error(),
-						"path":  voicePath,
-					})
-					transcribedText = "[voice (transcription failed)]"
-				} else {
-					transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
-					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]any{
-						"text": result.Text,
-					})
-				}
-			} else {
-				transcribedText = "[voice]"
-			}
-
 			if content != "" {
 				content += "\n"
 			}
-			content += transcribedText
+			content += "[voice]"
 		}
 	}
 

From 4c653c661db7e686ccd5a2a907ecb70a877fdaa6 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 04:11:11 +0800
Subject: [PATCH 44/52] refactor(channels): standardize group chat trigger
 filtering (Phase 8)

Add unified ShouldRespondInGroup to BaseChannel, replacing scattered
per-channel group filtering logic. Introduce GroupTriggerConfig (with
mention_only + prefixes), TypingConfig, and PlaceholderConfig types.
Migrate Discord MentionOnly, OneBot checkGroupTrigger, and LINE
hardcoded mention-only to the shared mechanism. Add group trigger
entry points for Slack, Telegram, QQ, Feishu, DingTalk, and WeCom.
Legacy config fields are preserved with automatic migration.
---
 pkg/channels/base.go              |  47 +++++++++
 pkg/channels/base_test.go         | 127 +++++++++++++++++++++-
 pkg/channels/dingtalk/dingtalk.go |  11 +-
 pkg/channels/discord/discord.go   |  25 +++--
 pkg/channels/feishu/feishu_64.go  |  10 +-
 pkg/channels/line/line.go         |  26 +++--
 pkg/channels/onebot/onebot.go     |  28 +----
 pkg/channels/qq/qq.go             |  11 +-
 pkg/channels/slack/slack.go       |  14 ++-
 pkg/channels/telegram/telegram.go |  63 +++++++++++
 pkg/channels/wecom/app.go         |   5 +-
 pkg/channels/wecom/bot.go         |  14 ++-
 pkg/config/config.go              | 170 +++++++++++++++++++-----------
 pkg/config/defaults.go            |   1 +
 14 files changed, 446 insertions(+), 106 deletions(-)

diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index adacb8c78..e345aedf0 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -8,6 +8,7 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/config"
 	"github.com/sipeed/picoclaw/pkg/media"
 )
 
@@ -30,6 +31,11 @@ func WithMaxMessageLength(n int) BaseChannelOption {
 	return func(c *BaseChannel) { c.maxMessageLength = n }
 }
 
+// WithGroupTrigger sets the group trigger configuration for a channel.
+func WithGroupTrigger(gt config.GroupTriggerConfig) BaseChannelOption {
+	return func(c *BaseChannel) { c.groupTrigger = gt }
+}
+
 // MessageLengthProvider is an opt-in interface that channels implement
 // to advertise their maximum message length. The Manager uses this via
 // type assertion to decide whether to split outbound messages.
@@ -44,6 +50,7 @@ type BaseChannel struct {
 	name             string
 	allowList        []string
 	maxMessageLength int
+	groupTrigger     config.GroupTriggerConfig
 	mediaStore       media.MediaStore
 }
 
@@ -72,6 +79,46 @@ func (c *BaseChannel) MaxMessageLength() int {
 	return c.maxMessageLength
 }
 
+// ShouldRespondInGroup determines whether the bot should respond in a group chat.
+// Each channel is responsible for:
+//  1. Detecting isMentioned (platform-specific)
+//  2. Stripping bot mention from content (platform-specific)
+//  3. Calling this method to get the group response decision
+//
+// Logic:
+//   - If isMentioned → always respond
+//   - If mention_only configured and not mentioned → ignore
+//   - If prefixes configured → respond if content starts with any prefix (strip it)
+//   - If prefixes configured but no match and not mentioned → ignore
+//   - Otherwise (no group_trigger configured) → respond to all (permissive default)
+func (c *BaseChannel) ShouldRespondInGroup(isMentioned bool, content string) (bool, string) {
+	gt := c.groupTrigger
+
+	// Mentioned → always respond
+	if isMentioned {
+		return true, strings.TrimSpace(content)
+	}
+
+	// mention_only → require mention
+	if gt.MentionOnly {
+		return false, content
+	}
+
+	// Prefix matching
+	if len(gt.Prefixes) > 0 {
+		for _, prefix := range gt.Prefixes {
+			if prefix != "" && strings.HasPrefix(content, prefix) {
+				return true, strings.TrimSpace(strings.TrimPrefix(content, prefix))
+			}
+		}
+		// Prefixes configured but none matched and not mentioned → ignore
+		return false, content
+	}
+
+	// No group_trigger configured → permissive (respond to all)
+	return true, strings.TrimSpace(content)
+}
+
 func (c *BaseChannel) Name() string {
 	return c.name
 }
diff --git a/pkg/channels/base_test.go b/pkg/channels/base_test.go
index 78c6d1d66..e56ad3ee9 100644
--- a/pkg/channels/base_test.go
+++ b/pkg/channels/base_test.go
@@ -1,6 +1,10 @@
 package channels
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/config"
+)
 
 func TestBaseChannelIsAllowed(t *testing.T) {
 	tests := []struct {
@@ -50,3 +54,124 @@ func TestBaseChannelIsAllowed(t *testing.T) {
 		})
 	}
 }
+
+func TestShouldRespondInGroup(t *testing.T) {
+	tests := []struct {
+		name        string
+		gt          config.GroupTriggerConfig
+		isMentioned bool
+		content     string
+		wantRespond bool
+		wantContent string
+	}{
+		{
+			name:        "no config - permissive default",
+			gt:          config.GroupTriggerConfig{},
+			isMentioned: false,
+			content:     "hello world",
+			wantRespond: true,
+			wantContent: "hello world",
+		},
+		{
+			name:        "no config - mentioned",
+			gt:          config.GroupTriggerConfig{},
+			isMentioned: true,
+			content:     "hello world",
+			wantRespond: true,
+			wantContent: "hello world",
+		},
+		{
+			name:        "mention_only - not mentioned",
+			gt:          config.GroupTriggerConfig{MentionOnly: true},
+			isMentioned: false,
+			content:     "hello world",
+			wantRespond: false,
+			wantContent: "hello world",
+		},
+		{
+			name:        "mention_only - mentioned",
+			gt:          config.GroupTriggerConfig{MentionOnly: true},
+			isMentioned: true,
+			content:     "hello world",
+			wantRespond: true,
+			wantContent: "hello world",
+		},
+		{
+			name:        "prefix match",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"/ask"}},
+			isMentioned: false,
+			content:     "/ask hello",
+			wantRespond: true,
+			wantContent: "hello",
+		},
+		{
+			name:        "prefix no match - not mentioned",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"/ask"}},
+			isMentioned: false,
+			content:     "hello world",
+			wantRespond: false,
+			wantContent: "hello world",
+		},
+		{
+			name:        "prefix no match - but mentioned",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"/ask"}},
+			isMentioned: true,
+			content:     "hello world",
+			wantRespond: true,
+			wantContent: "hello world",
+		},
+		{
+			name:        "multiple prefixes - second matches",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"/ask", "/bot"}},
+			isMentioned: false,
+			content:     "/bot help me",
+			wantRespond: true,
+			wantContent: "help me",
+		},
+		{
+			name:        "mention_only with prefixes - mentioned overrides",
+			gt:          config.GroupTriggerConfig{MentionOnly: true, Prefixes: []string{"/ask"}},
+			isMentioned: true,
+			content:     "hello",
+			wantRespond: true,
+			wantContent: "hello",
+		},
+		{
+			name:        "mention_only with prefixes - not mentioned, no prefix",
+			gt:          config.GroupTriggerConfig{MentionOnly: true, Prefixes: []string{"/ask"}},
+			isMentioned: false,
+			content:     "hello",
+			wantRespond: false,
+			wantContent: "hello",
+		},
+		{
+			name:        "empty prefix in list is skipped",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"", "/ask"}},
+			isMentioned: false,
+			content:     "/ask test",
+			wantRespond: true,
+			wantContent: "test",
+		},
+		{
+			name:        "prefix strips leading whitespace after prefix",
+			gt:          config.GroupTriggerConfig{Prefixes: []string{"/ask "}},
+			isMentioned: false,
+			content:     "/ask hello",
+			wantRespond: true,
+			wantContent: "hello",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ch := NewBaseChannel("test", nil, nil, nil, WithGroupTrigger(tt.gt))
+			gotRespond, gotContent := ch.ShouldRespondInGroup(tt.isMentioned, tt.content)
+			if gotRespond != tt.wantRespond {
+				t.Errorf("ShouldRespondInGroup() respond = %v, want %v", gotRespond, tt.wantRespond)
+			}
+			if gotContent != tt.wantContent {
+				t.Errorf("ShouldRespondInGroup() content = %q, want %q", gotContent, tt.wantContent)
+			}
+		})
+	}
+}
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index c49769761..b28bc850f 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -38,7 +38,10 @@ func NewDingTalkChannel(cfg config.DingTalkConfig, messageBus *bus.MessageBus) (
 		return nil, fmt.Errorf("dingtalk client_id and client_secret are required")
 	}
 
-	base := channels.NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(20000))
+	base := channels.NewBaseChannel("dingtalk", cfg, messageBus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(20000),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &DingTalkChannel{
 		BaseChannel:  base,
@@ -165,6 +168,12 @@ func (c *DingTalkChannel) onChatBotMessageReceived(
 		peer = bus.Peer{Kind: "direct", ID: senderID}
 	} else {
 		peer = bus.Peer{Kind: "group", ID: data.ConversationId}
+		// In group chats, apply unified group trigger filtering
+		respond, cleaned := c.ShouldRespondInGroup(false, content)
+		if !respond {
+			return nil, nil
+		}
+		content = cleaned
 	}
 
 	logger.DebugCF("dingtalk", "Received message", map[string]any{
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 68725b124..4ef4906c1 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -39,7 +39,10 @@ func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordC
 		return nil, fmt.Errorf("failed to create discord session: %w", err)
 	}
 
-	base := channels.NewBaseChannel("discord", cfg, bus, cfg.AllowFrom, channels.WithMaxMessageLength(2000))
+	base := channels.NewBaseChannel("discord", cfg, bus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(2000),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &DiscordChannel{
 		BaseChannel: base,
@@ -265,9 +268,11 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		return
 	}
 
-	// If configured to only respond to mentions, check if bot is mentioned
-	// Skip this check for DMs (GuildID is empty) - DMs should always be responded to
-	if c.config.MentionOnly && m.GuildID != "" {
+	content := m.Content
+
+	// In guild (group) channels, apply unified group trigger filtering
+	// DMs (GuildID is empty) always get a response
+	if m.GuildID != "" {
 		isMentioned := false
 		for _, mention := range m.Mentions {
 			if mention.ID == c.botUserID {
@@ -275,12 +280,18 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 				break
 			}
 		}
-		if !isMentioned {
-			logger.DebugCF("discord", "Message ignored - bot not mentioned", map[string]any{
+		content = c.stripBotMention(content)
+		respond, cleaned := c.ShouldRespondInGroup(isMentioned, content)
+		if !respond {
+			logger.DebugCF("discord", "Group message ignored by group trigger", map[string]any{
 				"user_id": m.Author.ID,
 			})
 			return
 		}
+		content = cleaned
+	} else {
+		// DMs: just strip bot mention without filtering
+		content = c.stripBotMention(content)
 	}
 
 	senderID := m.Author.ID
@@ -289,8 +300,6 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		senderName += "#" + m.Author.Discriminator
 	}
 
-	content := m.Content
-	content = c.stripBotMention(content)
 	mediaPaths := make([]string, 0, len(m.Attachments))
 
 	scope := channels.BuildMediaScope("discord", m.ChannelID, m.ID)
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index 5245cd99d..aaaf6cf1b 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -32,7 +32,9 @@ type FeishuChannel struct {
 }
 
 func NewFeishuChannel(cfg config.FeishuConfig, bus *bus.MessageBus) (*FeishuChannel, error) {
-	base := channels.NewBaseChannel("feishu", cfg, bus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("feishu", cfg, bus, cfg.AllowFrom,
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &FeishuChannel{
 		BaseChannel: base,
@@ -173,6 +175,12 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 		peer = bus.Peer{Kind: "direct", ID: senderID}
 	} else {
 		peer = bus.Peer{Kind: "group", ID: chatID}
+		// In group chats, apply unified group trigger filtering
+		respond, cleaned := c.ShouldRespondInGroup(false, content)
+		if !respond {
+			return nil
+		}
+		content = cleaned
 	}
 
 	logger.InfoCF("feishu", "Feishu message received", map[string]any{
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 5b0af4f1d..a79931bc9 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -59,7 +59,10 @@ func NewLINEChannel(cfg config.LINEConfig, messageBus *bus.MessageBus) (*LINECha
 		return nil, fmt.Errorf("line channel_secret and channel_access_token are required")
 	}
 
-	base := channels.NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(5000))
+	base := channels.NewBaseChannel("line", cfg, messageBus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(5000),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &LINEChannel{
 		BaseChannel: base,
@@ -262,14 +265,6 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 		return
 	}
 
-	// In group chats, only respond when the bot is mentioned
-	if isGroup && !c.isBotMentioned(msg) {
-		logger.DebugCF("line", "Ignoring group message without mention", map[string]any{
-			"chat_id": chatID,
-		})
-		return
-	}
-
 	// Store reply token for later use
 	if event.ReplyToken != "" {
 		c.replyTokens.Store(chatID, replyTokenEntry{
@@ -339,6 +334,19 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 		return
 	}
 
+	// In group chats, apply unified group trigger filtering
+	if isGroup {
+		isMentioned := c.isBotMentioned(msg)
+		respond, cleaned := c.ShouldRespondInGroup(isMentioned, content)
+		if !respond {
+			logger.DebugCF("line", "Ignoring group message by group trigger", map[string]any{
+				"chat_id": chatID,
+			})
+			return
+		}
+		content = cleaned
+	}
+
 	metadata := map[string]string{
 		"platform":    "line",
 		"source_type": event.Source.Type,
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 001965238..f32cb4948 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -97,7 +97,9 @@ type oneBotMessageSegment struct {
 }
 
 func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*OneBotChannel, error) {
-	base := channels.NewBaseChannel("onebot", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("onebot", cfg, messageBus, cfg.AllowFrom,
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	const dedupSize = 1024
 	return &OneBotChannel{
@@ -996,8 +998,8 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 			metadata["sender_name"] = sender.Nickname
 		}
 
-		triggered, strippedContent := c.checkGroupTrigger(content, isBotMentioned)
-		if !triggered {
+		respond, strippedContent := c.ShouldRespondInGroup(isBotMentioned, content)
+		if !respond {
 			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]any{
 				"sender":       senderID,
 				"group":        groupIDStr,
@@ -1069,23 +1071,3 @@ func truncate(s string, n int) string {
 	}
 	return string(runes[:n]) + "..."
 }
-
-func (c *OneBotChannel) checkGroupTrigger(
-	content string,
-	isBotMentioned bool,
-) (triggered bool, strippedContent string) {
-	if isBotMentioned {
-		return true, strings.TrimSpace(content)
-	}
-
-	for _, prefix := range c.config.GroupTriggerPrefix {
-		if prefix == "" {
-			continue
-		}
-		if strings.HasPrefix(content, prefix) {
-			return true, strings.TrimSpace(strings.TrimPrefix(content, prefix))
-		}
-	}
-
-	return false, content
-}
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 69f323e6e..011eb6c3c 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -32,7 +32,9 @@ type QQChannel struct {
 }
 
 func NewQQChannel(cfg config.QQConfig, messageBus *bus.MessageBus) (*QQChannel, error) {
-	base := channels.NewBaseChannel("qq", cfg, messageBus, cfg.AllowFrom)
+	base := channels.NewBaseChannel("qq", cfg, messageBus, cfg.AllowFrom,
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &QQChannel{
 		BaseChannel:  base,
@@ -204,6 +206,13 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			return nil
 		}
 
+		// GroupAT event means bot is always mentioned; apply group trigger filtering
+		respond, cleaned := c.ShouldRespondInGroup(true, content)
+		if !respond {
+			return nil
+		}
+		content = cleaned
+
 		logger.InfoCF("qq", "Received group AT message", map[string]any{
 			"sender": senderID,
 			"group":  data.GroupID,
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index a8d329d65..6fba2e0b4 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -47,7 +47,10 @@ func NewSlackChannel(cfg config.SlackConfig, messageBus *bus.MessageBus) (*Slack
 
 	socketClient := socketmode.New(api)
 
-	base := channels.NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(40000))
+	base := channels.NewBaseChannel("slack", cfg, messageBus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(40000),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &SlackChannel{
 		BaseChannel:  base,
@@ -279,6 +282,15 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 	content := ev.Text
 	content = c.stripBotMention(content)
 
+	// In non-DM channels, apply group trigger filtering
+	if !strings.HasPrefix(channelID, "D") {
+		respond, cleaned := c.ShouldRespondInGroup(false, content)
+		if !respond {
+			return
+		}
+		content = cleaned
+	}
+
 	var mediaPaths []string
 
 	scope := channels.BuildMediaScope("slack", chatID, messageTS)
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 9544987ec..c5c055163 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -81,6 +81,7 @@ func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChann
 		bus,
 		telegramCfg.AllowFrom,
 		channels.WithMaxMessageLength(4096),
+		channels.WithGroupTrigger(telegramCfg.GroupTrigger),
 	)
 
 	return &TelegramChannel{
@@ -417,6 +418,19 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		content = "[empty message]"
 	}
 
+	// In group chats, apply unified group trigger filtering
+	if message.Chat.Type != "private" {
+		isMentioned := c.isBotMentioned(message)
+		if isMentioned {
+			content = c.stripBotMention(content)
+		}
+		respond, cleaned := c.ShouldRespondInGroup(isMentioned, content)
+		if !respond {
+			return nil
+		}
+		content = cleaned
+	}
+
 	logger.DebugCF("telegram", "Received message", map[string]any{
 		"sender_id": senderID,
 		"chat_id":   fmt.Sprintf("%d", chatID),
@@ -629,3 +643,52 @@ func escapeHTML(text string) string {
 	text = strings.ReplaceAll(text, ">", "&gt;")
 	return text
 }
+
+// isBotMentioned checks if the bot is mentioned in the message via entities.
+func (c *TelegramChannel) isBotMentioned(message *telego.Message) bool {
+	botUsername := c.bot.Username()
+	if botUsername == "" {
+		return false
+	}
+
+	entities := message.Entities
+	if entities == nil {
+		entities = message.CaptionEntities
+	}
+
+	for _, entity := range entities {
+		if entity.Type == "mention" {
+			// Extract the mention text from the message
+			text := message.Text
+			if text == "" {
+				text = message.Caption
+			}
+			runes := []rune(text)
+			end := entity.Offset + entity.Length
+			if end <= len(runes) {
+				mention := string(runes[entity.Offset:end])
+				if strings.EqualFold(mention, "@"+botUsername) {
+					return true
+				}
+			}
+		}
+		if entity.Type == "text_mention" && entity.User != nil {
+			if entity.User.Username == botUsername {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// stripBotMention removes the @bot mention from the content.
+func (c *TelegramChannel) stripBotMention(content string) string {
+	botUsername := c.bot.Username()
+	if botUsername == "" {
+		return content
+	}
+	// Case-insensitive replacement
+	re := regexp.MustCompile(`(?i)@` + regexp.QuoteMeta(botUsername))
+	content = re.ReplaceAllString(content, "")
+	return strings.TrimSpace(content)
+}
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 4c2a4d326..53b53ffb8 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -122,7 +122,10 @@ func NewWeComAppChannel(cfg config.WeComAppConfig, messageBus *bus.MessageBus) (
 		return nil, fmt.Errorf("wecom_app corp_id, corp_secret and agent_id are required")
 	}
 
-	base := channels.NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(2048))
+	base := channels.NewBaseChannel("wecom_app", cfg, messageBus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(2048),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &WeComAppChannel{
 		BaseChannel:   base,
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index d5912bddc..7ffe4734b 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -86,7 +86,10 @@ func NewWeComBotChannel(cfg config.WeComConfig, messageBus *bus.MessageBus) (*We
 		return nil, fmt.Errorf("wecom token and webhook_url are required")
 	}
 
-	base := channels.NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom, channels.WithMaxMessageLength(2048))
+	base := channels.NewBaseChannel("wecom", cfg, messageBus, cfg.AllowFrom,
+		channels.WithMaxMessageLength(2048),
+		channels.WithGroupTrigger(cfg.GroupTrigger),
+	)
 
 	return &WeComBotChannel{
 		BaseChannel:   base,
@@ -367,6 +370,15 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 	// Build metadata
 	peer := bus.Peer{Kind: peerKind, ID: peerID}
 
+	// In group chats, apply unified group trigger filtering
+	if isGroupChat {
+		respond, cleaned := c.ShouldRespondInGroup(false, content)
+		if !respond {
+			return
+		}
+		content = cleaned
+	}
+
 	metadata := map[string]string{
 		"msg_type":     msg.MsgType,
 		"msg_id":       msg.MsgID,
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 2595398c7..cf768a79e 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -194,6 +194,23 @@ type ChannelsConfig struct {
 	WeComApp WeComAppConfig `json:"wecom_app"`
 }
 
+// GroupTriggerConfig controls when the bot responds in group chats.
+type GroupTriggerConfig struct {
+	MentionOnly bool     `json:"mention_only,omitempty"`
+	Prefixes    []string `json:"prefixes,omitempty"`
+}
+
+// TypingConfig controls typing indicator behavior (Phase 10).
+type TypingConfig struct {
+	Enabled bool `json:"enabled,omitempty"`
+}
+
+// PlaceholderConfig controls placeholder message behavior (Phase 10).
+type PlaceholderConfig struct {
+	Enabled bool   `json:"enabled,omitempty"`
+	Text    string `json:"text,omitempty"`
+}
+
 type WhatsAppConfig struct {
 	Enabled   bool                `json:"enabled"    env:"PICOCLAW_CHANNELS_WHATSAPP_ENABLED"`
 	BridgeURL string              `json:"bridge_url" env:"PICOCLAW_CHANNELS_WHATSAPP_BRIDGE_URL"`
@@ -201,26 +218,33 @@ type WhatsAppConfig struct {
 }
 
 type TelegramConfig struct {
-	Enabled   bool                `json:"enabled"    env:"PICOCLAW_CHANNELS_TELEGRAM_ENABLED"`
-	Token     string              `json:"token"      env:"PICOCLAW_CHANNELS_TELEGRAM_TOKEN"`
-	Proxy     string              `json:"proxy"      env:"PICOCLAW_CHANNELS_TELEGRAM_PROXY"`
-	AllowFrom FlexibleStringSlice `json:"allow_from" env:"PICOCLAW_CHANNELS_TELEGRAM_ALLOW_FROM"`
+	Enabled      bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_TELEGRAM_ENABLED"`
+	Token        string              `json:"token"                   env:"PICOCLAW_CHANNELS_TELEGRAM_TOKEN"`
+	Proxy        string              `json:"proxy"                   env:"PICOCLAW_CHANNELS_TELEGRAM_PROXY"`
+	AllowFrom    FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_TELEGRAM_ALLOW_FROM"`
+	GroupTrigger GroupTriggerConfig  `json:"group_trigger,omitempty"`
+	Typing       TypingConfig        `json:"typing,omitempty"`
+	Placeholder  PlaceholderConfig   `json:"placeholder,omitempty"`
 }
 
 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"`
+	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"`
 }
 
 type DiscordConfig struct {
-	Enabled     bool                `json:"enabled"      env:"PICOCLAW_CHANNELS_DISCORD_ENABLED"`
-	Token       string              `json:"token"        env:"PICOCLAW_CHANNELS_DISCORD_TOKEN"`
-	AllowFrom   FlexibleStringSlice `json:"allow_from"   env:"PICOCLAW_CHANNELS_DISCORD_ALLOW_FROM"`
-	MentionOnly bool                `json:"mention_only" env:"PICOCLAW_CHANNELS_DISCORD_MENTION_ONLY"`
+	Enabled      bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_DISCORD_ENABLED"`
+	Token        string              `json:"token"                   env:"PICOCLAW_CHANNELS_DISCORD_TOKEN"`
+	AllowFrom    FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_DISCORD_ALLOW_FROM"`
+	MentionOnly  bool                `json:"mention_only"            env:"PICOCLAW_CHANNELS_DISCORD_MENTION_ONLY"`
+	GroupTrigger GroupTriggerConfig  `json:"group_trigger,omitempty"`
+	Typing       TypingConfig        `json:"typing,omitempty"`
+	Placeholder  PlaceholderConfig   `json:"placeholder,omitempty"`
 }
 
 type MaixCamConfig struct {
@@ -231,69 +255,82 @@ type MaixCamConfig struct {
 }
 
 type QQConfig struct {
-	Enabled   bool                `json:"enabled"    env:"PICOCLAW_CHANNELS_QQ_ENABLED"`
-	AppID     string              `json:"app_id"     env:"PICOCLAW_CHANNELS_QQ_APP_ID"`
-	AppSecret string              `json:"app_secret" env:"PICOCLAW_CHANNELS_QQ_APP_SECRET"`
-	AllowFrom FlexibleStringSlice `json:"allow_from" env:"PICOCLAW_CHANNELS_QQ_ALLOW_FROM"`
+	Enabled      bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_QQ_ENABLED"`
+	AppID        string              `json:"app_id"                  env:"PICOCLAW_CHANNELS_QQ_APP_ID"`
+	AppSecret    string              `json:"app_secret"              env:"PICOCLAW_CHANNELS_QQ_APP_SECRET"`
+	AllowFrom    FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_QQ_ALLOW_FROM"`
+	GroupTrigger GroupTriggerConfig  `json:"group_trigger,omitempty"`
 }
 
 type DingTalkConfig struct {
-	Enabled      bool                `json:"enabled"       env:"PICOCLAW_CHANNELS_DINGTALK_ENABLED"`
-	ClientID     string              `json:"client_id"     env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_ID"`
-	ClientSecret string              `json:"client_secret" env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_SECRET"`
-	AllowFrom    FlexibleStringSlice `json:"allow_from"    env:"PICOCLAW_CHANNELS_DINGTALK_ALLOW_FROM"`
+	Enabled      bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_DINGTALK_ENABLED"`
+	ClientID     string              `json:"client_id"               env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_ID"`
+	ClientSecret string              `json:"client_secret"           env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_SECRET"`
+	AllowFrom    FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_DINGTALK_ALLOW_FROM"`
+	GroupTrigger GroupTriggerConfig  `json:"group_trigger,omitempty"`
 }
 
 type SlackConfig struct {
-	Enabled   bool                `json:"enabled"    env:"PICOCLAW_CHANNELS_SLACK_ENABLED"`
-	BotToken  string              `json:"bot_token"  env:"PICOCLAW_CHANNELS_SLACK_BOT_TOKEN"`
-	AppToken  string              `json:"app_token"  env:"PICOCLAW_CHANNELS_SLACK_APP_TOKEN"`
-	AllowFrom FlexibleStringSlice `json:"allow_from" env:"PICOCLAW_CHANNELS_SLACK_ALLOW_FROM"`
+	Enabled      bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_SLACK_ENABLED"`
+	BotToken     string              `json:"bot_token"               env:"PICOCLAW_CHANNELS_SLACK_BOT_TOKEN"`
+	AppToken     string              `json:"app_token"               env:"PICOCLAW_CHANNELS_SLACK_APP_TOKEN"`
+	AllowFrom    FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_SLACK_ALLOW_FROM"`
+	GroupTrigger GroupTriggerConfig  `json:"group_trigger,omitempty"`
+	Typing       TypingConfig        `json:"typing,omitempty"`
+	Placeholder  PlaceholderConfig   `json:"placeholder,omitempty"`
 }
 
 type LINEConfig struct {
-	Enabled            bool                `json:"enabled"              env:"PICOCLAW_CHANNELS_LINE_ENABLED"`
-	ChannelSecret      string              `json:"channel_secret"       env:"PICOCLAW_CHANNELS_LINE_CHANNEL_SECRET"`
-	ChannelAccessToken string              `json:"channel_access_token" env:"PICOCLAW_CHANNELS_LINE_CHANNEL_ACCESS_TOKEN"`
-	WebhookHost        string              `json:"webhook_host"         env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_HOST"`
-	WebhookPort        int                 `json:"webhook_port"         env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PORT"`
-	WebhookPath        string              `json:"webhook_path"         env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PATH"`
-	AllowFrom          FlexibleStringSlice `json:"allow_from"           env:"PICOCLAW_CHANNELS_LINE_ALLOW_FROM"`
+	Enabled            bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_LINE_ENABLED"`
+	ChannelSecret      string              `json:"channel_secret"          env:"PICOCLAW_CHANNELS_LINE_CHANNEL_SECRET"`
+	ChannelAccessToken string              `json:"channel_access_token"    env:"PICOCLAW_CHANNELS_LINE_CHANNEL_ACCESS_TOKEN"`
+	WebhookHost        string              `json:"webhook_host"            env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_HOST"`
+	WebhookPort        int                 `json:"webhook_port"            env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PORT"`
+	WebhookPath        string              `json:"webhook_path"            env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PATH"`
+	AllowFrom          FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_LINE_ALLOW_FROM"`
+	GroupTrigger       GroupTriggerConfig  `json:"group_trigger,omitempty"`
+	Typing             TypingConfig        `json:"typing,omitempty"`
+	Placeholder        PlaceholderConfig   `json:"placeholder,omitempty"`
 }
 
 type OneBotConfig struct {
-	Enabled            bool                `json:"enabled"              env:"PICOCLAW_CHANNELS_ONEBOT_ENABLED"`
-	WSUrl              string              `json:"ws_url"               env:"PICOCLAW_CHANNELS_ONEBOT_WS_URL"`
-	AccessToken        string              `json:"access_token"         env:"PICOCLAW_CHANNELS_ONEBOT_ACCESS_TOKEN"`
-	ReconnectInterval  int                 `json:"reconnect_interval"   env:"PICOCLAW_CHANNELS_ONEBOT_RECONNECT_INTERVAL"`
-	GroupTriggerPrefix []string            `json:"group_trigger_prefix" env:"PICOCLAW_CHANNELS_ONEBOT_GROUP_TRIGGER_PREFIX"`
-	AllowFrom          FlexibleStringSlice `json:"allow_from"           env:"PICOCLAW_CHANNELS_ONEBOT_ALLOW_FROM"`
+	Enabled            bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_ONEBOT_ENABLED"`
+	WSUrl              string              `json:"ws_url"                  env:"PICOCLAW_CHANNELS_ONEBOT_WS_URL"`
+	AccessToken        string              `json:"access_token"            env:"PICOCLAW_CHANNELS_ONEBOT_ACCESS_TOKEN"`
+	ReconnectInterval  int                 `json:"reconnect_interval"      env:"PICOCLAW_CHANNELS_ONEBOT_RECONNECT_INTERVAL"`
+	GroupTriggerPrefix []string            `json:"group_trigger_prefix"    env:"PICOCLAW_CHANNELS_ONEBOT_GROUP_TRIGGER_PREFIX"`
+	AllowFrom          FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_ONEBOT_ALLOW_FROM"`
+	GroupTrigger       GroupTriggerConfig  `json:"group_trigger,omitempty"`
+	Typing             TypingConfig        `json:"typing,omitempty"`
+	Placeholder        PlaceholderConfig   `json:"placeholder,omitempty"`
 }
 
 type WeComConfig struct {
-	Enabled        bool                `json:"enabled"          env:"PICOCLAW_CHANNELS_WECOM_ENABLED"`
-	Token          string              `json:"token"            env:"PICOCLAW_CHANNELS_WECOM_TOKEN"`
-	EncodingAESKey string              `json:"encoding_aes_key" env:"PICOCLAW_CHANNELS_WECOM_ENCODING_AES_KEY"`
-	WebhookURL     string              `json:"webhook_url"      env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_URL"`
-	WebhookHost    string              `json:"webhook_host"     env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_HOST"`
-	WebhookPort    int                 `json:"webhook_port"     env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_PORT"`
-	WebhookPath    string              `json:"webhook_path"     env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_PATH"`
-	AllowFrom      FlexibleStringSlice `json:"allow_from"       env:"PICOCLAW_CHANNELS_WECOM_ALLOW_FROM"`
-	ReplyTimeout   int                 `json:"reply_timeout"    env:"PICOCLAW_CHANNELS_WECOM_REPLY_TIMEOUT"`
+	Enabled        bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_WECOM_ENABLED"`
+	Token          string              `json:"token"                   env:"PICOCLAW_CHANNELS_WECOM_TOKEN"`
+	EncodingAESKey string              `json:"encoding_aes_key"        env:"PICOCLAW_CHANNELS_WECOM_ENCODING_AES_KEY"`
+	WebhookURL     string              `json:"webhook_url"             env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_URL"`
+	WebhookHost    string              `json:"webhook_host"            env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_HOST"`
+	WebhookPort    int                 `json:"webhook_port"            env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_PORT"`
+	WebhookPath    string              `json:"webhook_path"            env:"PICOCLAW_CHANNELS_WECOM_WEBHOOK_PATH"`
+	AllowFrom      FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_WECOM_ALLOW_FROM"`
+	ReplyTimeout   int                 `json:"reply_timeout"           env:"PICOCLAW_CHANNELS_WECOM_REPLY_TIMEOUT"`
+	GroupTrigger   GroupTriggerConfig  `json:"group_trigger,omitempty"`
 }
 
 type WeComAppConfig struct {
-	Enabled        bool                `json:"enabled"          env:"PICOCLAW_CHANNELS_WECOM_APP_ENABLED"`
-	CorpID         string              `json:"corp_id"          env:"PICOCLAW_CHANNELS_WECOM_APP_CORP_ID"`
-	CorpSecret     string              `json:"corp_secret"      env:"PICOCLAW_CHANNELS_WECOM_APP_CORP_SECRET"`
-	AgentID        int64               `json:"agent_id"         env:"PICOCLAW_CHANNELS_WECOM_APP_AGENT_ID"`
-	Token          string              `json:"token"            env:"PICOCLAW_CHANNELS_WECOM_APP_TOKEN"`
-	EncodingAESKey string              `json:"encoding_aes_key" env:"PICOCLAW_CHANNELS_WECOM_APP_ENCODING_AES_KEY"`
-	WebhookHost    string              `json:"webhook_host"     env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_HOST"`
-	WebhookPort    int                 `json:"webhook_port"     env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_PORT"`
-	WebhookPath    string              `json:"webhook_path"     env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_PATH"`
-	AllowFrom      FlexibleStringSlice `json:"allow_from"       env:"PICOCLAW_CHANNELS_WECOM_APP_ALLOW_FROM"`
-	ReplyTimeout   int                 `json:"reply_timeout"    env:"PICOCLAW_CHANNELS_WECOM_APP_REPLY_TIMEOUT"`
+	Enabled        bool                `json:"enabled"                 env:"PICOCLAW_CHANNELS_WECOM_APP_ENABLED"`
+	CorpID         string              `json:"corp_id"                 env:"PICOCLAW_CHANNELS_WECOM_APP_CORP_ID"`
+	CorpSecret     string              `json:"corp_secret"             env:"PICOCLAW_CHANNELS_WECOM_APP_CORP_SECRET"`
+	AgentID        int64               `json:"agent_id"                env:"PICOCLAW_CHANNELS_WECOM_APP_AGENT_ID"`
+	Token          string              `json:"token"                   env:"PICOCLAW_CHANNELS_WECOM_APP_TOKEN"`
+	EncodingAESKey string              `json:"encoding_aes_key"        env:"PICOCLAW_CHANNELS_WECOM_APP_ENCODING_AES_KEY"`
+	WebhookHost    string              `json:"webhook_host"            env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_HOST"`
+	WebhookPort    int                 `json:"webhook_port"            env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_PORT"`
+	WebhookPath    string              `json:"webhook_path"            env:"PICOCLAW_CHANNELS_WECOM_APP_WEBHOOK_PATH"`
+	AllowFrom      FlexibleStringSlice `json:"allow_from"              env:"PICOCLAW_CHANNELS_WECOM_APP_ALLOW_FROM"`
+	ReplyTimeout   int                 `json:"reply_timeout"           env:"PICOCLAW_CHANNELS_WECOM_APP_REPLY_TIMEOUT"`
+	GroupTrigger   GroupTriggerConfig  `json:"group_trigger,omitempty"`
 }
 
 type HeartbeatConfig struct {
@@ -507,6 +544,9 @@ func LoadConfig(path string) (*Config, error) {
 		return nil, err
 	}
 
+	// Migrate legacy channel config fields to new unified structures
+	cfg.migrateChannelConfigs()
+
 	// Auto-migrate: if only legacy providers config exists, convert to model_list
 	if len(cfg.ModelList) == 0 && cfg.HasProvidersConfig() {
 		cfg.ModelList = ConvertProvidersToModelList(cfg)
@@ -520,6 +560,18 @@ func LoadConfig(path string) (*Config, error) {
 	return cfg, nil
 }
 
+func (c *Config) migrateChannelConfigs() {
+	// Discord: mention_only -> group_trigger.mention_only
+	if c.Channels.Discord.MentionOnly && !c.Channels.Discord.GroupTrigger.MentionOnly {
+		c.Channels.Discord.GroupTrigger.MentionOnly = true
+	}
+
+	// OneBot: group_trigger_prefix -> group_trigger.prefixes
+	if len(c.Channels.OneBot.GroupTriggerPrefix) > 0 && len(c.Channels.OneBot.GroupTrigger.Prefixes) == 0 {
+		c.Channels.OneBot.GroupTrigger.Prefixes = c.Channels.OneBot.GroupTriggerPrefix
+	}
+}
+
 func SaveConfig(path string, cfg *Config) error {
 	data, err := json.MarshalIndent(cfg, "", "  ")
 	if err != nil {
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index b96ee4d89..03ad2ab6b 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -80,6 +80,7 @@ func DefaultConfig() *Config {
 				WebhookPort:        18791,
 				WebhookPath:        "/webhook/line",
 				AllowFrom:          FlexibleStringSlice{},
+				GroupTrigger:       GroupTriggerConfig{MentionOnly: true},
 			},
 			OneBot: OneBotConfig{
 				Enabled:            false,

From 90b4a6468311c4f7bdcb148052924c2bc1d436c6 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 04:55:15 +0800
Subject: [PATCH 45/52] feat(channels): add typing/placeholder automation and
 Pico Protocol channel (Phase 10 + 7)

Phase 10: Define TypingCapable, MessageEditor, PlaceholderRecorder interfaces.
Manager orchestrates outbound typing stop and placeholder editing via preSend.
Migrate Telegram, Discord, Slack, OneBot to register state with Manager instead
of handling locally in Send. Phase 7: Add native WebSocket Pico Protocol channel
as reference implementation of all optional capability interfaces.
---
 cmd/picoclaw/cmd_gateway.go       |   1 +
 pkg/channels/base.go              |  27 +-
 pkg/channels/discord/discord.go   |  14 +-
 pkg/channels/interfaces.go        |  24 ++
 pkg/channels/manager.go           |  56 ++++
 pkg/channels/manager_test.go      | 216 +++++++++++++++
 pkg/channels/onebot/onebot.go     |  13 +-
 pkg/channels/pico/init.go         |  13 +
 pkg/channels/pico/pico.go         | 430 ++++++++++++++++++++++++++++++
 pkg/channels/pico/protocol.go     |  46 ++++
 pkg/channels/slack/slack.go       |  24 ++
 pkg/channels/telegram/telegram.go | 113 +++-----
 pkg/config/config.go              |  12 +
 pkg/config/defaults.go            |  14 +
 14 files changed, 913 insertions(+), 90 deletions(-)
 create mode 100644 pkg/channels/interfaces.go
 create mode 100644 pkg/channels/pico/init.go
 create mode 100644 pkg/channels/pico/pico.go
 create mode 100644 pkg/channels/pico/protocol.go

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 837c55f37..33217492d 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -20,6 +20,7 @@ import (
 	_ "github.com/sipeed/picoclaw/pkg/channels/line"
 	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
 	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
+	_ "github.com/sipeed/picoclaw/pkg/channels/pico"
 	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
 	_ "github.com/sipeed/picoclaw/pkg/channels/slack"
 	_ "github.com/sipeed/picoclaw/pkg/channels/telegram"
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index e345aedf0..c22a27eb9 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -44,14 +44,15 @@ type MessageLengthProvider interface {
 }
 
 type BaseChannel struct {
-	config           any
-	bus              *bus.MessageBus
-	running          atomic.Bool
-	name             string
-	allowList        []string
-	maxMessageLength int
-	groupTrigger     config.GroupTriggerConfig
-	mediaStore       media.MediaStore
+	config              any
+	bus                 *bus.MessageBus
+	running             atomic.Bool
+	name                string
+	allowList           []string
+	maxMessageLength    int
+	groupTrigger        config.GroupTriggerConfig
+	mediaStore          media.MediaStore
+	placeholderRecorder PlaceholderRecorder
 }
 
 func NewBaseChannel(
@@ -203,6 +204,16 @@ func (c *BaseChannel) SetMediaStore(s media.MediaStore) { c.mediaStore = s }
 // GetMediaStore returns the injected MediaStore (may be nil).
 func (c *BaseChannel) GetMediaStore() media.MediaStore { return c.mediaStore }
 
+// SetPlaceholderRecorder injects a PlaceholderRecorder into the channel.
+func (c *BaseChannel) SetPlaceholderRecorder(r PlaceholderRecorder) {
+	c.placeholderRecorder = r
+}
+
+// GetPlaceholderRecorder returns the injected PlaceholderRecorder (may be nil).
+func (c *BaseChannel) GetPlaceholderRecorder() PlaceholderRecorder {
+	return c.placeholderRecorder
+}
+
 // BuildMediaScope constructs a scope key for media lifecycle tracking.
 func BuildMediaScope(channel, chatID, messageID string) string {
 	id := messageID
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 4ef4906c1..ee698da61 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -106,8 +106,6 @@ func (c *DiscordChannel) Stop(ctx context.Context) error {
 }
 
 func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
-	c.stopTyping(msg.ChatID)
-
 	if !c.IsRunning() {
 		return channels.ErrNotRunning
 	}
@@ -126,8 +124,6 @@ func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 
 // SendMedia implements the channels.MediaSender interface.
 func (c *DiscordChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
-	c.stopTyping(msg.ChatID)
-
 	if !c.IsRunning() {
 		return channels.ErrNotRunning
 	}
@@ -221,6 +217,12 @@ func (c *DiscordChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMes
 	}
 }
 
+// EditMessage implements channels.MessageEditor.
+func (c *DiscordChannel) EditMessage(ctx context.Context, chatID string, messageID string, content string) error {
+	_, err := c.session.ChannelMessageEdit(chatID, messageID, content)
+	return err
+}
+
 func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
 	// Use the passed ctx for timeout control
 	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
@@ -350,6 +352,10 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 
 	// Start typing after all early returns — guaranteed to have a matching Send()
 	c.startTyping(m.ChannelID)
+	// Register typing stop with Manager for outbound orchestration
+	if rec := c.GetPlaceholderRecorder(); rec != nil {
+		rec.RecordTypingStop("discord", m.ChannelID, func() { c.stopTyping(m.ChannelID) })
+	}
 
 	logger.DebugCF("discord", "Received message", map[string]any{
 		"sender_name": senderName,
diff --git a/pkg/channels/interfaces.go b/pkg/channels/interfaces.go
new file mode 100644
index 000000000..32bfe95f8
--- /dev/null
+++ b/pkg/channels/interfaces.go
@@ -0,0 +1,24 @@
+package channels
+
+import "context"
+
+// TypingCapable — channels that can show a typing/thinking indicator.
+// StartTyping begins the indicator and returns a stop function.
+// The stop function MUST be idempotent and safe to call multiple times.
+type TypingCapable interface {
+	StartTyping(ctx context.Context, chatID string) (stop func(), err error)
+}
+
+// MessageEditor — channels that can edit an existing message.
+// messageID is always string; channels convert platform-specific types internally.
+type MessageEditor interface {
+	EditMessage(ctx context.Context, chatID string, messageID string, content string) error
+}
+
+// PlaceholderRecorder is injected into channels by Manager.
+// Channels call these methods on inbound to register typing/placeholder state.
+// Manager uses the registered state on outbound to stop typing and edit placeholders.
+type PlaceholderRecorder interface {
+	RecordPlaceholder(channel, chatID, placeholderID string)
+	RecordTypingStop(channel, chatID string, stop func())
+}
diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 92412edeb..4b1a43b7b 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -62,12 +62,55 @@ type Manager struct {
 	mux          *http.ServeMux
 	httpServer   *http.Server
 	mu           sync.RWMutex
+	placeholders sync.Map // "channel:chatID" → placeholderID (string)
+	typingStops  sync.Map // "channel:chatID" → func()
 }
 
 type asyncTask struct {
 	cancel context.CancelFunc
 }
 
+// RecordPlaceholder registers a placeholder message for later editing.
+// Implements PlaceholderRecorder.
+func (m *Manager) RecordPlaceholder(channel, chatID, placeholderID string) {
+	key := channel + ":" + chatID
+	m.placeholders.Store(key, placeholderID)
+}
+
+// RecordTypingStop registers a typing stop function for later invocation.
+// Implements PlaceholderRecorder.
+func (m *Manager) RecordTypingStop(channel, chatID string, stop func()) {
+	key := channel + ":" + chatID
+	m.typingStops.Store(key, stop)
+}
+
+// preSend handles typing stop and placeholder editing before sending a message.
+// Returns true if the message was edited into a placeholder (skip Send).
+func (m *Manager) preSend(ctx context.Context, name string, msg bus.OutboundMessage, ch Channel) bool {
+	key := name + ":" + msg.ChatID
+
+	// 1. Stop typing
+	if v, loaded := m.typingStops.LoadAndDelete(key); loaded {
+		if stop, ok := v.(func()); ok {
+			stop() // idempotent, safe
+		}
+	}
+
+	// 2. Try editing placeholder
+	if v, loaded := m.placeholders.LoadAndDelete(key); loaded {
+		if placeholderID, ok := v.(string); ok && placeholderID != "" {
+			if editor, ok := ch.(MessageEditor); ok {
+				if err := editor.EditMessage(ctx, msg.ChatID, placeholderID, msg.Content); err == nil {
+					return true // edited successfully, skip Send
+				}
+				// edit failed → fall through to normal Send
+			}
+		}
+	}
+
+	return false
+}
+
 func NewManager(cfg *config.Config, messageBus *bus.MessageBus, store media.MediaStore) (*Manager, error) {
 	m := &Manager{
 		channels:   make(map[string]Channel),
@@ -109,6 +152,10 @@ func (m *Manager) initChannel(name, displayName string) {
 				setter.SetMediaStore(m.mediaStore)
 			}
 		}
+		// Inject PlaceholderRecorder if channel supports it
+		if setter, ok := ch.(interface{ SetPlaceholderRecorder(PlaceholderRecorder) }); ok {
+			setter.SetPlaceholderRecorder(m)
+		}
 		m.channels[name] = ch
 		m.workers[name] = newChannelWorker(name, ch)
 		logger.InfoCF("channels", "Channel enabled successfully", map[string]any{
@@ -168,6 +215,10 @@ func (m *Manager) initChannels() error {
 		m.initChannel("wecom_app", "WeCom App")
 	}
 
+	if m.config.Channels.Pico.Enabled && m.config.Channels.Pico.Token != "" {
+		m.initChannel("pico", "Pico")
+	}
+
 	logger.InfoCF("channels", "Channel initialization completed", map[string]any{
 		"enabled_channels": len(m.channels),
 	})
@@ -383,6 +434,11 @@ func (m *Manager) sendWithRetry(ctx context.Context, name string, w *channelWork
 		return
 	}
 
+	// Pre-send: stop typing and try to edit placeholder
+	if m.preSend(ctx, name, msg, w.ch) {
+		return // placeholder was edited successfully, skip Send
+	}
+
 	var lastErr error
 	for attempt := 0; attempt <= maxRetries; attempt++ {
 		lastErr = w.ch.Send(ctx, msg)
diff --git a/pkg/channels/manager_test.go b/pkg/channels/manager_test.go
index 162c9f8c9..0573c0a8e 100644
--- a/pkg/channels/manager_test.go
+++ b/pkg/channels/manager_test.go
@@ -416,3 +416,219 @@ func TestSendWithRetry_ExponentialBackoff(t *testing.T) {
 		t.Fatalf("expected %d calls, got %d", maxRetries+1, callCount.Load())
 	}
 }
+
+// --- Phase 10: preSend orchestration tests ---
+
+// mockMessageEditor is a channel that supports MessageEditor.
+type mockMessageEditor struct {
+	mockChannel
+	editFn func(ctx context.Context, chatID, messageID, content string) error
+}
+
+func (m *mockMessageEditor) EditMessage(ctx context.Context, chatID, messageID, content string) error {
+	return m.editFn(ctx, chatID, messageID, content)
+}
+
+func TestPreSend_PlaceholderEditSuccess(t *testing.T) {
+	m := newTestManager()
+	var sendCalled bool
+	var editCalled bool
+
+	ch := &mockMessageEditor{
+		mockChannel: mockChannel{
+			sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+				sendCalled = true
+				return nil
+			},
+		},
+		editFn: func(_ context.Context, chatID, messageID, content string) error {
+			editCalled = true
+			if chatID != "123" {
+				t.Fatalf("expected chatID 123, got %s", chatID)
+			}
+			if messageID != "456" {
+				t.Fatalf("expected messageID 456, got %s", messageID)
+			}
+			if content != "hello" {
+				t.Fatalf("expected content 'hello', got %s", content)
+			}
+			return nil
+		},
+	}
+
+	// Register placeholder
+	m.RecordPlaceholder("test", "123", "456")
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	edited := m.preSend(context.Background(), "test", msg, ch)
+
+	if !edited {
+		t.Fatal("expected preSend to return true (placeholder edited)")
+	}
+	if !editCalled {
+		t.Fatal("expected EditMessage to be called")
+	}
+	if sendCalled {
+		t.Fatal("expected Send to NOT be called when placeholder edited")
+	}
+}
+
+func TestPreSend_PlaceholderEditFails_FallsThrough(t *testing.T) {
+	m := newTestManager()
+
+	ch := &mockMessageEditor{
+		mockChannel: mockChannel{
+			sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+				return nil
+			},
+		},
+		editFn: func(_ context.Context, _, _, _ string) error {
+			return fmt.Errorf("edit failed")
+		},
+	}
+
+	m.RecordPlaceholder("test", "123", "456")
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	edited := m.preSend(context.Background(), "test", msg, ch)
+
+	if edited {
+		t.Fatal("expected preSend to return false when edit fails")
+	}
+}
+
+func TestPreSend_TypingStopCalled(t *testing.T) {
+	m := newTestManager()
+	var stopCalled bool
+
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			return nil
+		},
+	}
+
+	m.RecordTypingStop("test", "123", func() {
+		stopCalled = true
+	})
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	m.preSend(context.Background(), "test", msg, ch)
+
+	if !stopCalled {
+		t.Fatal("expected typing stop func to be called")
+	}
+}
+
+func TestPreSend_NoRegisteredState(t *testing.T) {
+	m := newTestManager()
+
+	ch := &mockChannel{
+		sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+			return nil
+		},
+	}
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	edited := m.preSend(context.Background(), "test", msg, ch)
+
+	if edited {
+		t.Fatal("expected preSend to return false with no registered state")
+	}
+}
+
+func TestPreSend_TypingAndPlaceholder(t *testing.T) {
+	m := newTestManager()
+	var stopCalled bool
+	var editCalled bool
+
+	ch := &mockMessageEditor{
+		mockChannel: mockChannel{
+			sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+				return nil
+			},
+		},
+		editFn: func(_ context.Context, _, _, _ string) error {
+			editCalled = true
+			return nil
+		},
+	}
+
+	m.RecordTypingStop("test", "123", func() {
+		stopCalled = true
+	})
+	m.RecordPlaceholder("test", "123", "456")
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	edited := m.preSend(context.Background(), "test", msg, ch)
+
+	if !stopCalled {
+		t.Fatal("expected typing stop to be called")
+	}
+	if !editCalled {
+		t.Fatal("expected EditMessage to be called")
+	}
+	if !edited {
+		t.Fatal("expected preSend to return true")
+	}
+}
+
+func TestRecordPlaceholder_ConcurrentSafe(t *testing.T) {
+	m := newTestManager()
+
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			chatID := fmt.Sprintf("chat_%d", i%10)
+			m.RecordPlaceholder("test", chatID, fmt.Sprintf("msg_%d", i))
+		}(i)
+	}
+	wg.Wait()
+}
+
+func TestRecordTypingStop_ConcurrentSafe(t *testing.T) {
+	m := newTestManager()
+
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			chatID := fmt.Sprintf("chat_%d", i%10)
+			m.RecordTypingStop("test", chatID, func() {})
+		}(i)
+	}
+	wg.Wait()
+}
+
+func TestSendWithRetry_PreSendEditsPlaceholder(t *testing.T) {
+	m := newTestManager()
+	var sendCalled bool
+
+	ch := &mockMessageEditor{
+		mockChannel: mockChannel{
+			sendFn: func(_ context.Context, _ bus.OutboundMessage) error {
+				sendCalled = true
+				return nil
+			},
+		},
+		editFn: func(_ context.Context, _, _, _ string) error {
+			return nil // edit succeeds
+		},
+	}
+
+	m.RecordPlaceholder("test", "123", "456")
+
+	w := &channelWorker{
+		ch:      ch,
+		limiter: rate.NewLimiter(rate.Inf, 1),
+	}
+
+	msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}
+	m.sendWithRetry(context.Background(), "test", w, msg)
+
+	if sendCalled {
+		t.Fatal("expected Send to NOT be called when placeholder was edited")
+	}
+}
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index f32cb4948..682025b67 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -418,12 +418,6 @@ func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 		return fmt.Errorf("onebot send: %w", channels.ErrTemporary)
 	}
 
-	if msgID, ok := c.pendingEmojiMsg.LoadAndDelete(msg.ChatID); ok {
-		if mid, ok := msgID.(string); ok && mid != "" {
-			c.setMsgEmojiLike(mid, 289, false)
-		}
-	}
-
 	return nil
 }
 
@@ -1037,6 +1031,13 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 	if raw.MessageType == "group" && messageID != "" && messageID != "0" {
 		c.setMsgEmojiLike(messageID, 289, true)
 		c.pendingEmojiMsg.Store(chatID, messageID)
+		// Register emoji stop with Manager for outbound orchestration
+		if rec := c.GetPlaceholderRecorder(); rec != nil {
+			capturedMsgID := messageID
+			rec.RecordTypingStop("onebot", chatID, func() {
+				c.setMsgEmojiLike(capturedMsgID, 289, false)
+			})
+		}
 	}
 
 	c.HandleMessage(peer, messageID, senderID, chatID, content, parsed.Media, metadata)
diff --git a/pkg/channels/pico/init.go b/pkg/channels/pico/init.go
new file mode 100644
index 000000000..96d764418
--- /dev/null
+++ b/pkg/channels/pico/init.go
@@ -0,0 +1,13 @@
+package pico
+
+import (
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+func init() {
+	channels.RegisterFactory("pico", func(cfg *config.Config, b *bus.MessageBus) (channels.Channel, error) {
+		return NewPicoChannel(cfg.Channels.Pico, b)
+	})
+}
diff --git a/pkg/channels/pico/pico.go b/pkg/channels/pico/pico.go
new file mode 100644
index 000000000..1c28ca732
--- /dev/null
+++ b/pkg/channels/pico/pico.go
@@ -0,0 +1,430 @@
+package pico
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+)
+
+// picoConn represents a single WebSocket connection.
+type picoConn struct {
+	id        string
+	conn      *websocket.Conn
+	sessionID string
+	writeMu   sync.Mutex
+	closed    atomic.Bool
+}
+
+// writeJSON sends a JSON message to the connection with write locking.
+func (pc *picoConn) writeJSON(v any) error {
+	if pc.closed.Load() {
+		return fmt.Errorf("connection closed")
+	}
+	pc.writeMu.Lock()
+	defer pc.writeMu.Unlock()
+	return pc.conn.WriteJSON(v)
+}
+
+// close closes the connection.
+func (pc *picoConn) close() {
+	if pc.closed.CompareAndSwap(false, true) {
+		pc.conn.Close()
+	}
+}
+
+// PicoChannel implements the native Pico Protocol WebSocket channel.
+// It serves as the reference implementation for all optional capability interfaces.
+type PicoChannel struct {
+	*channels.BaseChannel
+	config      config.PicoConfig
+	upgrader    websocket.Upgrader
+	connections sync.Map // connID → *picoConn
+	connCount   atomic.Int32
+	ctx         context.Context
+	cancel      context.CancelFunc
+}
+
+// NewPicoChannel creates a new Pico Protocol channel.
+func NewPicoChannel(cfg config.PicoConfig, messageBus *bus.MessageBus) (*PicoChannel, error) {
+	if cfg.Token == "" {
+		return nil, fmt.Errorf("pico token is required")
+	}
+
+	base := channels.NewBaseChannel("pico", cfg, messageBus, cfg.AllowFrom)
+
+	allowOrigins := cfg.AllowOrigins
+	checkOrigin := func(r *http.Request) bool {
+		if len(allowOrigins) == 0 {
+			return true // allow all if not configured
+		}
+		origin := r.Header.Get("Origin")
+		for _, allowed := range allowOrigins {
+			if allowed == "*" || allowed == origin {
+				return true
+			}
+		}
+		return false
+	}
+
+	return &PicoChannel{
+		BaseChannel: base,
+		config:      cfg,
+		upgrader: websocket.Upgrader{
+			CheckOrigin:     checkOrigin,
+			ReadBufferSize:  1024,
+			WriteBufferSize: 1024,
+		},
+	}, nil
+}
+
+// Start implements Channel.
+func (c *PicoChannel) Start(ctx context.Context) error {
+	logger.InfoC("pico", "Starting Pico Protocol channel")
+	c.ctx, c.cancel = context.WithCancel(ctx)
+	c.SetRunning(true)
+	logger.InfoC("pico", "Pico Protocol channel started")
+	return nil
+}
+
+// Stop implements Channel.
+func (c *PicoChannel) Stop(ctx context.Context) error {
+	logger.InfoC("pico", "Stopping Pico Protocol channel")
+	c.SetRunning(false)
+
+	// Close all connections
+	c.connections.Range(func(key, value any) bool {
+		if pc, ok := value.(*picoConn); ok {
+			pc.close()
+		}
+		c.connections.Delete(key)
+		return true
+	})
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	logger.InfoC("pico", "Pico Protocol channel stopped")
+	return nil
+}
+
+// WebhookPath implements channels.WebhookHandler.
+func (c *PicoChannel) WebhookPath() string { return "/pico/" }
+
+// ServeHTTP implements http.Handler for the shared HTTP server.
+func (c *PicoChannel) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	path := strings.TrimPrefix(r.URL.Path, "/pico")
+
+	switch {
+	case path == "/ws" || path == "/ws/":
+		c.handleWebSocket(w, r)
+	default:
+		http.NotFound(w, r)
+	}
+}
+
+// Send implements Channel — sends a message to the appropriate WebSocket connection.
+func (c *PicoChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return channels.ErrNotRunning
+	}
+
+	outMsg := newMessage(TypeMessageCreate, map[string]any{
+		"content": msg.Content,
+	})
+
+	return c.broadcastToSession(msg.ChatID, outMsg)
+}
+
+// EditMessage implements channels.MessageEditor.
+func (c *PicoChannel) EditMessage(ctx context.Context, chatID string, messageID string, content string) error {
+	outMsg := newMessage(TypeMessageUpdate, map[string]any{
+		"message_id": messageID,
+		"content":    content,
+	})
+	return c.broadcastToSession(chatID, outMsg)
+}
+
+// StartTyping implements channels.TypingCapable.
+func (c *PicoChannel) StartTyping(ctx context.Context, chatID string) (func(), error) {
+	startMsg := newMessage(TypeTypingStart, nil)
+	if err := c.broadcastToSession(chatID, startMsg); err != nil {
+		return func() {}, err
+	}
+	return func() {
+		stopMsg := newMessage(TypeTypingStop, nil)
+		c.broadcastToSession(chatID, stopMsg)
+	}, nil
+}
+
+// broadcastToSession sends a message to all connections with a matching session.
+func (c *PicoChannel) broadcastToSession(chatID string, msg PicoMessage) error {
+	// chatID format: "pico:<sessionID>"
+	sessionID := strings.TrimPrefix(chatID, "pico:")
+	msg.SessionID = sessionID
+
+	var sent bool
+	c.connections.Range(func(key, value any) bool {
+		pc, ok := value.(*picoConn)
+		if !ok {
+			return true
+		}
+		if pc.sessionID == sessionID {
+			if err := pc.writeJSON(msg); err != nil {
+				logger.DebugCF("pico", "Write to connection failed", map[string]any{
+					"conn_id": pc.id,
+					"error":   err.Error(),
+				})
+			} else {
+				sent = true
+			}
+		}
+		return true
+	})
+
+	if !sent {
+		return fmt.Errorf("no active connections for session %s: %w", sessionID, channels.ErrSendFailed)
+	}
+	return nil
+}
+
+// handleWebSocket upgrades the HTTP connection and manages the WebSocket lifecycle.
+func (c *PicoChannel) handleWebSocket(w http.ResponseWriter, r *http.Request) {
+	if !c.IsRunning() {
+		http.Error(w, "channel not running", http.StatusServiceUnavailable)
+		return
+	}
+
+	// Authenticate
+	if !c.authenticate(r) {
+		http.Error(w, "unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Check connection limit
+	maxConns := c.config.MaxConnections
+	if maxConns <= 0 {
+		maxConns = 100
+	}
+	if int(c.connCount.Load()) >= maxConns {
+		http.Error(w, "too many connections", http.StatusServiceUnavailable)
+		return
+	}
+
+	conn, err := c.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		logger.ErrorCF("pico", "WebSocket upgrade failed", map[string]any{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	// Determine session ID from query param or generate one
+	sessionID := r.URL.Query().Get("session_id")
+	if sessionID == "" {
+		sessionID = uuid.New().String()
+	}
+
+	pc := &picoConn{
+		id:        uuid.New().String(),
+		conn:      conn,
+		sessionID: sessionID,
+	}
+
+	c.connections.Store(pc.id, pc)
+	c.connCount.Add(1)
+
+	logger.InfoCF("pico", "WebSocket client connected", map[string]any{
+		"conn_id":    pc.id,
+		"session_id": sessionID,
+	})
+
+	go c.readLoop(pc)
+}
+
+// authenticate checks the Bearer token from header or query parameter.
+func (c *PicoChannel) authenticate(r *http.Request) bool {
+	token := c.config.Token
+	if token == "" {
+		return false
+	}
+
+	// Check Authorization header
+	auth := r.Header.Get("Authorization")
+	if strings.HasPrefix(auth, "Bearer ") {
+		if strings.TrimPrefix(auth, "Bearer ") == token {
+			return true
+		}
+	}
+
+	// Check query parameter
+	if r.URL.Query().Get("token") == token {
+		return true
+	}
+
+	return false
+}
+
+// readLoop reads messages from a WebSocket connection.
+func (c *PicoChannel) readLoop(pc *picoConn) {
+	defer func() {
+		pc.close()
+		c.connections.Delete(pc.id)
+		c.connCount.Add(-1)
+		logger.InfoCF("pico", "WebSocket client disconnected", map[string]any{
+			"conn_id":    pc.id,
+			"session_id": pc.sessionID,
+		})
+	}()
+
+	readTimeout := time.Duration(c.config.ReadTimeout) * time.Second
+	if readTimeout <= 0 {
+		readTimeout = 60 * time.Second
+	}
+
+	_ = pc.conn.SetReadDeadline(time.Now().Add(readTimeout))
+	pc.conn.SetPongHandler(func(appData string) error {
+		_ = pc.conn.SetReadDeadline(time.Now().Add(readTimeout))
+		return nil
+	})
+
+	// Start ping ticker
+	pingInterval := time.Duration(c.config.PingInterval) * time.Second
+	if pingInterval <= 0 {
+		pingInterval = 30 * time.Second
+	}
+	go c.pingLoop(pc, pingInterval)
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+		}
+
+		_, rawMsg, err := pc.conn.ReadMessage()
+		if err != nil {
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNormalClosure) {
+				logger.DebugCF("pico", "WebSocket read error", map[string]any{
+					"conn_id": pc.id,
+					"error":   err.Error(),
+				})
+			}
+			return
+		}
+
+		_ = pc.conn.SetReadDeadline(time.Now().Add(readTimeout))
+
+		var msg PicoMessage
+		if err := json.Unmarshal(rawMsg, &msg); err != nil {
+			errMsg := newError("invalid_message", "failed to parse message")
+			pc.writeJSON(errMsg)
+			continue
+		}
+
+		c.handleMessage(pc, msg)
+	}
+}
+
+// pingLoop sends periodic ping frames to keep the connection alive.
+func (c *PicoChannel) pingLoop(pc *picoConn, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-ticker.C:
+			if pc.closed.Load() {
+				return
+			}
+			pc.writeMu.Lock()
+			err := pc.conn.WriteMessage(websocket.PingMessage, nil)
+			pc.writeMu.Unlock()
+			if err != nil {
+				return
+			}
+		}
+	}
+}
+
+// handleMessage processes an inbound Pico Protocol message.
+func (c *PicoChannel) handleMessage(pc *picoConn, msg PicoMessage) {
+	switch msg.Type {
+	case TypePing:
+		pong := newMessage(TypePong, nil)
+		pong.ID = msg.ID
+		pc.writeJSON(pong)
+
+	case TypeMessageSend:
+		c.handleMessageSend(pc, msg)
+
+	default:
+		errMsg := newError("unknown_type", fmt.Sprintf("unknown message type: %s", msg.Type))
+		pc.writeJSON(errMsg)
+	}
+}
+
+// handleMessageSend processes an inbound message.send from a client.
+func (c *PicoChannel) handleMessageSend(pc *picoConn, msg PicoMessage) {
+	content, _ := msg.Payload["content"].(string)
+	if strings.TrimSpace(content) == "" {
+		errMsg := newError("empty_content", "message content is empty")
+		pc.writeJSON(errMsg)
+		return
+	}
+
+	sessionID := msg.SessionID
+	if sessionID == "" {
+		sessionID = pc.sessionID
+	}
+
+	chatID := "pico:" + sessionID
+	senderID := "pico-user"
+
+	peer := bus.Peer{Kind: "direct", ID: "pico:" + sessionID}
+
+	metadata := map[string]string{
+		"platform":   "pico",
+		"session_id": sessionID,
+		"conn_id":    pc.id,
+	}
+
+	logger.DebugCF("pico", "Received message", map[string]any{
+		"session_id": sessionID,
+		"preview":    truncate(content, 50),
+	})
+
+	// Register typing with Manager
+	if rec := c.GetPlaceholderRecorder(); rec != nil {
+		stop, err := c.StartTyping(c.ctx, chatID)
+		if err == nil {
+			rec.RecordTypingStop("pico", chatID, stop)
+		}
+	}
+
+	c.HandleMessage(peer, msg.ID, senderID, chatID, content, nil, metadata)
+}
+
+// truncate truncates a string to maxLen runes.
+func truncate(s string, maxLen int) string {
+	runes := []rune(s)
+	if len(runes) <= maxLen {
+		return s
+	}
+	return string(runes[:maxLen]) + "..."
+}
diff --git a/pkg/channels/pico/protocol.go b/pkg/channels/pico/protocol.go
new file mode 100644
index 000000000..ca18df1dd
--- /dev/null
+++ b/pkg/channels/pico/protocol.go
@@ -0,0 +1,46 @@
+package pico
+
+import "time"
+
+// Protocol message types.
+const (
+	// Client → Server
+	TypeMessageSend = "message.send"
+	TypeMediaSend   = "media.send"
+	TypePing        = "ping"
+
+	// Server → Client
+	TypeMessageCreate = "message.create"
+	TypeMessageUpdate = "message.update"
+	TypeMediaCreate   = "media.create"
+	TypeTypingStart   = "typing.start"
+	TypeTypingStop    = "typing.stop"
+	TypeError         = "error"
+	TypePong          = "pong"
+)
+
+// PicoMessage is the wire format for all Pico Protocol messages.
+type PicoMessage struct {
+	Type      string         `json:"type"`
+	ID        string         `json:"id,omitempty"`
+	SessionID string         `json:"session_id,omitempty"`
+	Timestamp int64          `json:"timestamp,omitempty"`
+	Payload   map[string]any `json:"payload,omitempty"`
+}
+
+// newMessage creates a PicoMessage with the given type and payload.
+func newMessage(msgType string, payload map[string]any) PicoMessage {
+	return PicoMessage{
+		Type:      msgType,
+		Timestamp: time.Now().UnixMilli(),
+		Payload:   payload,
+	}
+}
+
+// newError creates an error PicoMessage.
+func newError(code, message string) PicoMessage {
+	return newMessage(TypeError, map[string]any{
+		"code":    code,
+		"message": message,
+	})
+}
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index 6fba2e0b4..e64525310 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -274,6 +274,18 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		Timestamp: messageTS,
 	})
 
+	// Register typing stop (remove "eyes" reaction) with Manager
+	if rec := c.GetPlaceholderRecorder(); rec != nil {
+		capturedChannelID := channelID
+		capturedMessageTS := messageTS
+		rec.RecordTypingStop("slack", chatID, func() {
+			c.api.RemoveReaction("eyes", slack.ItemRef{
+				Channel:   capturedChannelID,
+				Timestamp: capturedMessageTS,
+			})
+		})
+	}
+
 	c.pendingAcks.Store(chatID, slackMessageRef{
 		ChannelID: channelID,
 		Timestamp: messageTS,
@@ -380,6 +392,18 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		Timestamp: messageTS,
 	})
 
+	// Register typing stop (remove "eyes" reaction) with Manager
+	if rec := c.GetPlaceholderRecorder(); rec != nil {
+		capturedChannelID := channelID
+		capturedMessageTS := messageTS
+		rec.RecordTypingStop("slack", chatID, func() {
+			c.api.RemoveReaction("eyes", slack.ItemRef{
+				Channel:   capturedChannelID,
+				Timestamp: capturedMessageTS,
+			})
+		})
+	}
+
 	c.pendingAcks.Store(chatID, slackMessageRef{
 		ChannelID: channelID,
 		Timestamp: messageTS,
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index c5c055163..98477f3a8 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -7,8 +7,8 @@ import (
 	"net/url"
 	"os"
 	"regexp"
+	"strconv"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/mymmrac/telego"
@@ -26,25 +26,13 @@ import (
 
 type TelegramChannel struct {
 	*channels.BaseChannel
-	bot          *telego.Bot
-	bh           *telegohandler.BotHandler
-	commands     TelegramCommander
-	config       *config.Config
-	chatIDs      map[string]int64
-	ctx          context.Context
-	cancel       context.CancelFunc
-	placeholders sync.Map // chatID -> messageID
-	stopThinking sync.Map // chatID -> thinkingCancel
-}
-
-type thinkingCancel struct {
-	fn context.CancelFunc
-}
-
-func (c *thinkingCancel) Cancel() {
-	if c != nil && c.fn != nil {
-		c.fn()
-	}
+	bot      *telego.Bot
+	bh       *telegohandler.BotHandler
+	commands TelegramCommander
+	config   *config.Config
+	chatIDs  map[string]int64
+	ctx      context.Context
+	cancel   context.CancelFunc
 }
 
 func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChannel, error) {
@@ -85,13 +73,11 @@ func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChann
 	)
 
 	return &TelegramChannel{
-		BaseChannel:  base,
-		commands:     NewTelegramCommands(bot, cfg),
-		bot:          bot,
-		config:       cfg,
-		chatIDs:      make(map[string]int64),
-		placeholders: sync.Map{},
-		stopThinking: sync.Map{},
+		BaseChannel: base,
+		commands:    NewTelegramCommands(bot, cfg),
+		bot:         bot,
+		config:      cfg,
+		chatIDs:     make(map[string]int64),
 	}, nil
 }
 
@@ -149,21 +135,6 @@ func (c *TelegramChannel) Stop(ctx context.Context) error {
 	logger.InfoC("telegram", "Stopping Telegram bot...")
 	c.SetRunning(false)
 
-	// Clean up all thinking cancel functions to avoid context leaks
-	c.stopThinking.Range(func(key, value any) bool {
-		if cf, ok := value.(*thinkingCancel); ok && cf != nil {
-			cf.Cancel()
-		}
-		c.stopThinking.Delete(key)
-		return true
-	})
-
-	// Clean up placeholder state
-	c.placeholders.Range(func(key, value any) bool {
-		c.placeholders.Delete(key)
-		return true
-	})
-
 	// Stop the bot handler
 	if c.bh != nil {
 		c.bh.Stop()
@@ -187,28 +158,9 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 		return fmt.Errorf("invalid chat ID %s: %w", msg.ChatID, channels.ErrSendFailed)
 	}
 
-	// Stop thinking animation
-	if stop, ok := c.stopThinking.Load(msg.ChatID); ok {
-		if cf, ok := stop.(*thinkingCancel); ok && cf != nil {
-			cf.Cancel()
-		}
-		c.stopThinking.Delete(msg.ChatID)
-	}
-
 	htmlContent := markdownToTelegramHTML(msg.Content)
 
-	// Try to edit placeholder
-	if pID, ok := c.placeholders.Load(msg.ChatID); ok {
-		c.placeholders.Delete(msg.ChatID)
-		editMsg := tu.EditMessageText(tu.ID(chatID), pID.(int), htmlContent)
-		editMsg.ParseMode = telego.ModeHTML
-
-		if _, err = c.bot.EditMessageText(ctx, editMsg); err == nil {
-			return nil
-		}
-		// Fallback to new message if edit fails
-	}
-
+	// Typing/placeholder handled by Manager.preSend — just send the message
 	tgMsg := tu.Message(tu.ID(chatID), htmlContent)
 	tgMsg.ParseMode = telego.ModeHTML
 
@@ -225,6 +177,23 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return nil
 }
 
+// EditMessage implements channels.MessageEditor.
+func (c *TelegramChannel) EditMessage(ctx context.Context, chatID string, messageID string, content string) error {
+	cid, err := parseChatID(chatID)
+	if err != nil {
+		return err
+	}
+	mid, err := strconv.Atoi(messageID)
+	if err != nil {
+		return err
+	}
+	htmlContent := markdownToTelegramHTML(content)
+	editMsg := tu.EditMessageText(tu.ID(cid), mid, htmlContent)
+	editMsg.ParseMode = telego.ModeHTML
+	_, err = c.bot.EditMessageText(ctx, editMsg)
+	return err
+}
+
 // SendMedia implements the channels.MediaSender interface.
 func (c *TelegramChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error {
 	if !c.IsRunning() {
@@ -445,21 +414,21 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		})
 	}
 
-	// Stop any previous thinking animation
-	if prevStop, ok := c.stopThinking.Load(chatIDStr); ok {
-		if cf, ok := prevStop.(*thinkingCancel); ok && cf != nil {
-			cf.Cancel()
-		}
-	}
-
-	// Create cancel function for thinking state
+	// Create cancel function for thinking state and register with Manager
 	_, thinkCancel := context.WithTimeout(ctx, 5*time.Minute)
-	c.stopThinking.Store(chatIDStr, &thinkingCancel{fn: thinkCancel})
+	if rec := c.GetPlaceholderRecorder(); rec != nil {
+		rec.RecordTypingStop("telegram", chatIDStr, thinkCancel)
+	} else {
+		// No recorder — cancel immediately to avoid context leak
+		thinkCancel()
+	}
 
 	pMsg, err := c.bot.SendMessage(ctx, tu.Message(tu.ID(chatID), "Thinking... 💭"))
 	if err == nil {
 		pID := pMsg.MessageID
-		c.placeholders.Store(chatIDStr, pID)
+		if rec := c.GetPlaceholderRecorder(); rec != nil {
+			rec.RecordPlaceholder("telegram", chatIDStr, fmt.Sprintf("%d", pID))
+		}
 	}
 
 	peerKind := "direct"
diff --git a/pkg/config/config.go b/pkg/config/config.go
index cf768a79e..35bbefb24 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -192,6 +192,7 @@ type ChannelsConfig struct {
 	OneBot   OneBotConfig   `json:"onebot"`
 	WeCom    WeComConfig    `json:"wecom"`
 	WeComApp WeComAppConfig `json:"wecom_app"`
+	Pico     PicoConfig     `json:"pico"`
 }
 
 // GroupTriggerConfig controls when the bot responds in group chats.
@@ -333,6 +334,17 @@ type WeComAppConfig struct {
 	GroupTrigger   GroupTriggerConfig  `json:"group_trigger,omitempty"`
 }
 
+type PicoConfig struct {
+	Enabled        bool                `json:"enabled"                   env:"PICOCLAW_CHANNELS_PICO_ENABLED"`
+	Token          string              `json:"token"                     env:"PICOCLAW_CHANNELS_PICO_TOKEN"`
+	AllowOrigins   []string            `json:"allow_origins,omitempty"`
+	PingInterval   int                 `json:"ping_interval,omitempty"`   // seconds, default 30
+	ReadTimeout    int                 `json:"read_timeout,omitempty"`    // seconds, default 60
+	WriteTimeout   int                 `json:"write_timeout,omitempty"`   // seconds, default 10
+	MaxConnections int                 `json:"max_connections,omitempty"` // default 100
+	AllowFrom      FlexibleStringSlice `json:"allow_from"                env:"PICOCLAW_CHANNELS_PICO_ALLOW_FROM"`
+}
+
 type HeartbeatConfig struct {
 	Enabled  bool `json:"enabled"  env:"PICOCLAW_HEARTBEAT_ENABLED"`
 	Interval int  `json:"interval" env:"PICOCLAW_HEARTBEAT_INTERVAL"` // minutes, min 5
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index 03ad2ab6b..604b53e24 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -33,6 +33,11 @@ func DefaultConfig() *Config {
 				Enabled:   false,
 				Token:     "",
 				AllowFrom: FlexibleStringSlice{},
+				Typing:    TypingConfig{Enabled: true},
+				Placeholder: PlaceholderConfig{
+					Enabled: true,
+					Text:    "Thinking... 💭",
+				},
 			},
 			Feishu: FeishuConfig{
 				Enabled:           false,
@@ -114,6 +119,15 @@ func DefaultConfig() *Config {
 				AllowFrom:      FlexibleStringSlice{},
 				ReplyTimeout:   5,
 			},
+			Pico: PicoConfig{
+				Enabled:        false,
+				Token:          "",
+				PingInterval:   30,
+				ReadTimeout:    60,
+				WriteTimeout:   10,
+				MaxConnections: 100,
+				AllowFrom:      FlexibleStringSlice{},
+			},
 		},
 		Providers: ProvidersConfig{
 			OpenAI: OpenAIProviderConfig{WebSearch: true},

From ced55e768ccfb7d14cfee8de691504baff88a9f0 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 05:22:18 +0800
Subject: [PATCH 46/52] fix: resolve golangci-lint issues in channel system

---
 pkg/channels/manager.go       | 2 +-
 pkg/channels/pico/protocol.go | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 4b1a43b7b..8e72efc5c 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -153,7 +153,7 @@ func (m *Manager) initChannel(name, displayName string) {
 			}
 		}
 		// Inject PlaceholderRecorder if channel supports it
-		if setter, ok := ch.(interface{ SetPlaceholderRecorder(PlaceholderRecorder) }); ok {
+		if setter, ok := ch.(interface{ SetPlaceholderRecorder(r PlaceholderRecorder) }); ok {
 			setter.SetPlaceholderRecorder(m)
 		}
 		m.channels[name] = ch
diff --git a/pkg/channels/pico/protocol.go b/pkg/channels/pico/protocol.go
index ca18df1dd..0a630e193 100644
--- a/pkg/channels/pico/protocol.go
+++ b/pkg/channels/pico/protocol.go
@@ -4,12 +4,12 @@ import "time"
 
 // Protocol message types.
 const (
-	// Client → Server
+	// TypeMessageSend is sent from client to server.
 	TypeMessageSend = "message.send"
 	TypeMediaSend   = "media.send"
 	TypePing        = "ping"
 
-	// Server → Client
+	// TypeMessageCreate is sent from server to client.
 	TypeMessageCreate = "message.create"
 	TypeMessageUpdate = "message.update"
 	TypeMediaCreate   = "media.create"

From f4b0f080e29ae3304ded321b67cbb1697e3a5157 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 05:46:34 +0800
Subject: [PATCH 47/52] refactor(channels): move SplitMessage from pkg/utils to
 pkg/channels

Message splitting is exclusively a Manager responsibility. Moving it
into the channels package eliminates the cross-package dependency and
aligns with the refactoring plan.
---
 pkg/channels/manager.go                               | 3 +--
 pkg/{utils/message.go => channels/split.go}           | 2 +-
 pkg/{utils/message_test.go => channels/split_test.go} | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)
 rename pkg/{utils/message.go => channels/split.go} (99%)
 rename pkg/{utils/message_test.go => channels/split_test.go} (99%)

diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go
index 8e72efc5c..07c2ce1e2 100644
--- a/pkg/channels/manager.go
+++ b/pkg/channels/manager.go
@@ -23,7 +23,6 @@ import (
 	"github.com/sipeed/picoclaw/pkg/health"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
-	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
 const (
@@ -407,7 +406,7 @@ func (m *Manager) runWorker(ctx context.Context, name string, w *channelWorker)
 				maxLen = mlp.MaxMessageLength()
 			}
 			if maxLen > 0 && len([]rune(msg.Content)) > maxLen {
-				chunks := utils.SplitMessage(msg.Content, maxLen)
+				chunks := SplitMessage(msg.Content, maxLen)
 				for _, chunk := range chunks {
 					chunkMsg := msg
 					chunkMsg.Content = chunk
diff --git a/pkg/utils/message.go b/pkg/channels/split.go
similarity index 99%
rename from pkg/utils/message.go
rename to pkg/channels/split.go
index 52a967f4c..a455c5741 100644
--- a/pkg/utils/message.go
+++ b/pkg/channels/split.go
@@ -1,4 +1,4 @@
-package utils
+package channels
 
 import (
 	"strings"
diff --git a/pkg/utils/message_test.go b/pkg/channels/split_test.go
similarity index 99%
rename from pkg/utils/message_test.go
rename to pkg/channels/split_test.go
index 78e1e2b40..d6356bdb9 100644
--- a/pkg/utils/message_test.go
+++ b/pkg/channels/split_test.go
@@ -1,4 +1,4 @@
-package utils
+package channels
 
 import (
 	"strings"

From db3c1e011ffdc2632377a0a38837a6eba6566b5e Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 06:03:23 +0800
Subject: [PATCH 48/52] fix: address PR review feedback across channel system

- MediaStore: use full UUID to prevent ref collisions, preserve and
  expose metadata via ResolveWithMeta, include underlying OS errors
- Agent loop: populate MediaPart Type/Filename/ContentType from
  MediaStore metadata so channels can dispatch media correctly
- SplitMessage: fix byte-vs-rune index mixup in code block header
  parsing, remove dead candidateStr variable
- Pico auth: restrict query-param token behind AllowTokenQuery config
  flag (default false) to prevent token leakage via logs/referer
- HandleMessage: replace context.TODO with caller-propagated ctx,
  log PublishInbound failures instead of silently discarding
- Gateway shutdown: use fresh 15s timeout context for StopAll so
  graceful shutdown is not short-circuited by the cancelled parent ctx
---
 cmd/picoclaw/cmd_gateway.go       |  8 +++++-
 pkg/agent/loop.go                 | 42 ++++++++++++++++++++++++++++-
 pkg/channels/base.go              | 10 ++++++-
 pkg/channels/dingtalk/dingtalk.go |  2 +-
 pkg/channels/discord/discord.go   |  2 +-
 pkg/channels/feishu/feishu_64.go  |  4 +--
 pkg/channels/line/line.go         |  2 +-
 pkg/channels/maixcam/maixcam.go   | 11 +++++++-
 pkg/channels/onebot/onebot.go     |  2 +-
 pkg/channels/pico/pico.go         | 13 +++++----
 pkg/channels/qq/qq.go             |  4 +--
 pkg/channels/slack/slack.go       |  6 ++---
 pkg/channels/split.go             | 18 +++++++++----
 pkg/channels/telegram/telegram.go |  2 +-
 pkg/channels/wecom/app.go         |  2 +-
 pkg/channels/wecom/bot.go         |  2 +-
 pkg/channels/whatsapp/whatsapp.go |  2 +-
 pkg/config/config.go              | 17 ++++++------
 pkg/media/store.go                | 41 +++++++++++++++++++++-------
 pkg/media/store_test.go           | 44 +++++++++++++++++++++++++++++++
 20 files changed, 187 insertions(+), 47 deletions(-)

diff --git a/cmd/picoclaw/cmd_gateway.go b/cmd/picoclaw/cmd_gateway.go
index 33217492d..798ad2813 100644
--- a/cmd/picoclaw/cmd_gateway.go
+++ b/cmd/picoclaw/cmd_gateway.go
@@ -190,7 +190,13 @@ func gatewayCmd() {
 	fmt.Println("\nShutting down...")
 	cancel()
 	msgBus.Close()
-	channelManager.StopAll(ctx)
+
+	// Use a fresh context with timeout for graceful shutdown,
+	// since the original ctx is already cancelled.
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer shutdownCancel()
+
+	channelManager.StopAll(shutdownCtx)
 	deviceService.Stop()
 	heartbeatService.Stop()
 	cronService.Stop()
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 050303101..0e2097488 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -10,6 +10,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -237,6 +238,36 @@ func (al *AgentLoop) SetMediaStore(s media.MediaStore) {
 	al.mediaStore = s
 }
 
+// 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"
+}
+
 // 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 {
@@ -731,7 +762,16 @@ func (al *AgentLoop) runLLMIteration(
 			if len(toolResult.Media) > 0 && opts.SendResponse {
 				parts := make([]bus.MediaPart, 0, len(toolResult.Media))
 				for _, ref := range toolResult.Media {
-					parts = append(parts, bus.MediaPart{Ref: ref})
+					part := bus.MediaPart{Ref: ref}
+					// Populate metadata from MediaStore when available
+					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,
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index c22a27eb9..c6a5f1cdc 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 )
 
@@ -168,6 +169,7 @@ func (c *BaseChannel) IsAllowed(senderID string) bool {
 }
 
 func (c *BaseChannel) HandleMessage(
+	ctx context.Context,
 	peer bus.Peer,
 	messageID, senderID, chatID, content string,
 	media []string,
@@ -191,7 +193,13 @@ func (c *BaseChannel) HandleMessage(
 		Metadata:   metadata,
 	}
 
-	c.bus.PublishInbound(context.TODO(), msg)
+	if err := c.bus.PublishInbound(ctx, msg); err != nil {
+		logger.ErrorCF("channels", "Failed to publish inbound message", map[string]any{
+			"channel": c.name,
+			"chat_id": chatID,
+			"error":   err.Error(),
+		})
+	}
 }
 
 func (c *BaseChannel) SetRunning(running bool) {
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index b28bc850f..7ab73b4d3 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -183,7 +183,7 @@ func (c *DingTalkChannel) onChatBotMessageReceived(
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(peer, "", senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, "", senderID, chatID, content, nil, metadata)
 
 	// Return nil to indicate we've handled the message asynchronously
 	// The response will be sent through the message bus
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index ee698da61..464a4db7b 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -381,7 +381,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		"is_dm":        fmt.Sprintf("%t", m.GuildID == ""),
 	}
 
-	c.HandleMessage(peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata)
 }
 
 // startTyping starts a continuous typing indicator loop for the given chatID.
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index aaaf6cf1b..4b8eddd21 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -131,7 +131,7 @@ func (c *FeishuChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
 	return nil
 }
 
-func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2MessageReceiveV1) error {
+func (c *FeishuChannel) handleMessageReceive(ctx context.Context, event *larkim.P2MessageReceiveV1) error {
 	if event == nil || event.Event == nil || event.Event.Message == nil {
 		return nil
 	}
@@ -189,7 +189,7 @@ func (c *FeishuChannel) handleMessageReceive(_ context.Context, event *larkim.P2
 		"preview":   utils.Truncate(content, 80),
 	})
 
-	c.HandleMessage(peer, messageID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata)
 	return nil
 }
 
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index a79931bc9..399617064 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -370,7 +370,7 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	// Show typing/loading indicator (requires user ID, not group ID)
 	c.sendLoading(senderID)
 
-	c.HandleMessage(peer, msg.ID, senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, mediaPaths, metadata)
 }
 
 // isBotMentioned checks if the bot is mentioned in the message.
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index b5b7259f9..dceaec4c5 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -179,7 +179,16 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
 		"h":         fmt.Sprintf("%.0f", h),
 	}
 
-	c.HandleMessage(bus.Peer{Kind: "channel", ID: "default"}, "", senderID, chatID, content, []string{}, metadata)
+	c.HandleMessage(
+		c.ctx,
+		bus.Peer{Kind: "channel", ID: "default"},
+		"",
+		senderID,
+		chatID,
+		content,
+		[]string{},
+		metadata,
+	)
 }
 
 func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) {
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index 682025b67..b47685397 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -1040,7 +1040,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		}
 	}
 
-	c.HandleMessage(peer, messageID, senderID, chatID, content, parsed.Media, metadata)
+	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, parsed.Media, metadata)
 }
 
 func (c *OneBotChannel) isDuplicate(messageID string) bool {
diff --git a/pkg/channels/pico/pico.go b/pkg/channels/pico/pico.go
index 1c28ca732..9809786e3 100644
--- a/pkg/channels/pico/pico.go
+++ b/pkg/channels/pico/pico.go
@@ -255,7 +255,8 @@ func (c *PicoChannel) handleWebSocket(w http.ResponseWriter, r *http.Request) {
 	go c.readLoop(pc)
 }
 
-// authenticate checks the Bearer token from header or query parameter.
+// authenticate checks the Bearer token from the Authorization header.
+// Query parameter authentication is only allowed when AllowTokenQuery is explicitly enabled.
 func (c *PicoChannel) authenticate(r *http.Request) bool {
 	token := c.config.Token
 	if token == "" {
@@ -270,9 +271,11 @@ func (c *PicoChannel) authenticate(r *http.Request) bool {
 		}
 	}
 
-	// Check query parameter
-	if r.URL.Query().Get("token") == token {
-		return true
+	// Check query parameter only when explicitly allowed
+	if c.config.AllowTokenQuery {
+		if r.URL.Query().Get("token") == token {
+			return true
+		}
 	}
 
 	return false
@@ -417,7 +420,7 @@ func (c *PicoChannel) handleMessageSend(pc *picoConn, msg PicoMessage) {
 		}
 	}
 
-	c.HandleMessage(peer, msg.ID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, nil, metadata)
 }
 
 // truncate truncates a string to maxLen runes.
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 011eb6c3c..c43c13655 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -168,7 +168,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 		// 转发到消息总线
 		metadata := map[string]string{}
 
-		c.HandleMessage(
+		c.HandleMessage(c.ctx,
 			bus.Peer{Kind: "direct", ID: senderID},
 			data.ID,
 			senderID,
@@ -224,7 +224,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			"group_id": data.GroupID,
 		}
 
-		c.HandleMessage(
+		c.HandleMessage(c.ctx,
 			bus.Peer{Kind: "group", ID: data.GroupID},
 			data.ID,
 			senderID,
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index e64525310..c6b3c829e 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -360,7 +360,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		"has_thread": threadTS != "",
 	})
 
-	c.HandleMessage(peer, messageTS, senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, messageTS, senderID, chatID, content, mediaPaths, metadata)
 }
 
 func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
@@ -433,7 +433,7 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		"team_id":    c.teamID,
 	}
 
-	c.HandleMessage(mentionPeer, messageTS, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(c.ctx, mentionPeer, messageTS, senderID, chatID, content, nil, metadata)
 }
 
 func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
@@ -476,7 +476,7 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		"text":      utils.Truncate(content, 50),
 	})
 
-	c.HandleMessage(bus.Peer{Kind: "channel", ID: channelID}, "", senderID, chatID, content, nil, metadata)
+	c.HandleMessage(c.ctx, bus.Peer{Kind: "channel", ID: channelID}, "", senderID, chatID, content, nil, metadata)
 }
 
 func (c *SlackChannel) downloadSlackFile(file slack.File) string {
diff --git a/pkg/channels/split.go b/pkg/channels/split.go
index a455c5741..27d76df1b 100644
--- a/pkg/channels/split.go
+++ b/pkg/channels/split.go
@@ -66,9 +66,8 @@ func SplitMessage(content string, maxLen int) []string {
 				} else {
 					// Code block is too long to fit in one chunk or missing closing fence.
 					// Try to split inside by injecting closing and reopening fences.
-					candidateStr := string(candidate)
-					unclosedStr := string(runes[unclosedIdx:])
-					headerEnd := strings.Index(unclosedStr, "\n")
+					fenceRunes := runes[unclosedIdx:]
+					headerEnd := findNewlineInRunes(fenceRunes)
 					var header string
 					if headerEnd == -1 {
 						header = strings.TrimSpace(string(runes[unclosedIdx : unclosedIdx+3]))
@@ -80,8 +79,6 @@ func SplitMessage(content string, maxLen int) []string {
 						headerEndIdx = unclosedIdx + headerEnd
 					}
 
-					_ = candidateStr // used above for context
-
 					// If we have a reasonable amount of content after the header, split inside
 					if msgEnd > headerEndIdx+20 {
 						// Find a better split point closer to maxLen
@@ -170,6 +167,17 @@ func findNextClosingCodeBlockRunes(runes []rune, startIdx int) int {
 	return -1
 }
 
+// findNewlineInRunes finds the first newline character in a rune slice.
+// Returns the rune index of the newline or -1 if not found.
+func findNewlineInRunes(runes []rune) int {
+	for i, r := range runes {
+		if r == '\n' {
+			return i
+		}
+	}
+	return -1
+}
+
 // findLastNewlineRunes finds the last newline character within the last N runes
 // Returns the rune position of the newline or -1 if not found
 func findLastNewlineRunes(runes []rune, searchWindow int) int {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 98477f3a8..31be4d489 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -448,7 +448,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		"is_group":   fmt.Sprintf("%t", message.Chat.Type != "private"),
 	}
 
-	c.HandleMessage(
+	c.HandleMessage(c.ctx,
 		peer,
 		messageID,
 		fmt.Sprintf("%d", user.ID),
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index 53b53ffb8..e822e67b2 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -630,7 +630,7 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(peer, messageID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata)
 }
 
 // tokenRefreshLoop periodically refreshes the access token
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 7ffe4734b..401c9c5ec 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -399,7 +399,7 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 	})
 
 	// Handle the message through the base channel
-	c.HandleMessage(peer, msg.MsgID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, msg.MsgID, senderID, chatID, content, nil, metadata)
 }
 
 // sendWebhookReply sends a reply using the webhook URL
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index 97032334f..b4599b5a0 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -224,5 +224,5 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
 		"preview": utils.Truncate(content, 50),
 	})
 
-	c.HandleMessage(peer, messageID, senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, mediaPaths, metadata)
 }
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 35bbefb24..fd5def625 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -335,14 +335,15 @@ type WeComAppConfig struct {
 }
 
 type PicoConfig struct {
-	Enabled        bool                `json:"enabled"                   env:"PICOCLAW_CHANNELS_PICO_ENABLED"`
-	Token          string              `json:"token"                     env:"PICOCLAW_CHANNELS_PICO_TOKEN"`
-	AllowOrigins   []string            `json:"allow_origins,omitempty"`
-	PingInterval   int                 `json:"ping_interval,omitempty"`   // seconds, default 30
-	ReadTimeout    int                 `json:"read_timeout,omitempty"`    // seconds, default 60
-	WriteTimeout   int                 `json:"write_timeout,omitempty"`   // seconds, default 10
-	MaxConnections int                 `json:"max_connections,omitempty"` // default 100
-	AllowFrom      FlexibleStringSlice `json:"allow_from"                env:"PICOCLAW_CHANNELS_PICO_ALLOW_FROM"`
+	Enabled         bool                `json:"enabled"                     env:"PICOCLAW_CHANNELS_PICO_ENABLED"`
+	Token           string              `json:"token"                       env:"PICOCLAW_CHANNELS_PICO_TOKEN"`
+	AllowTokenQuery bool                `json:"allow_token_query,omitempty"`
+	AllowOrigins    []string            `json:"allow_origins,omitempty"`
+	PingInterval    int                 `json:"ping_interval,omitempty"`
+	ReadTimeout     int                 `json:"read_timeout,omitempty"`
+	WriteTimeout    int                 `json:"write_timeout,omitempty"`
+	MaxConnections  int                 `json:"max_connections,omitempty"`
+	AllowFrom       FlexibleStringSlice `json:"allow_from"                  env:"PICOCLAW_CHANNELS_PICO_ALLOW_FROM"`
 }
 
 type HeartbeatConfig struct {
diff --git a/pkg/media/store.go b/pkg/media/store.go
index 8d03c03ef..2df4420e9 100644
--- a/pkg/media/store.go
+++ b/pkg/media/store.go
@@ -25,23 +25,32 @@ type MediaStore interface {
 	// Resolve returns the local file path for a given ref.
 	Resolve(ref string) (localPath string, err error)
 
+	// ResolveWithMeta returns the local file path and metadata for a given ref.
+	ResolveWithMeta(ref string) (localPath string, meta MediaMeta, err error)
+
 	// ReleaseAll deletes all files registered under the given scope
 	// and removes the mapping entries. File-not-exist errors are ignored.
 	ReleaseAll(scope string) error
 }
 
+// mediaEntry holds the path and metadata for a stored media file.
+type mediaEntry struct {
+	path string
+	meta MediaMeta
+}
+
 // FileMediaStore is a pure in-memory implementation of MediaStore.
 // Files are expected to already exist on disk (e.g. in /tmp/picoclaw_media/).
 type FileMediaStore struct {
 	mu          sync.RWMutex
-	refToPath   map[string]string
+	refs        map[string]mediaEntry
 	scopeToRefs map[string]map[string]struct{}
 }
 
 // NewFileMediaStore creates a new FileMediaStore.
 func NewFileMediaStore() *FileMediaStore {
 	return &FileMediaStore{
-		refToPath:   make(map[string]string),
+		refs:        make(map[string]mediaEntry),
 		scopeToRefs: make(map[string]map[string]struct{}),
 	}
 }
@@ -49,15 +58,15 @@ func NewFileMediaStore() *FileMediaStore {
 // Store registers a local file under the given scope. The file must exist.
 func (s *FileMediaStore) Store(localPath string, meta MediaMeta, scope string) (string, error) {
 	if _, err := os.Stat(localPath); err != nil {
-		return "", fmt.Errorf("media store: file does not exist: %s", localPath)
+		return "", fmt.Errorf("media store: %s: %w", localPath, err)
 	}
 
-	ref := "media://" + uuid.New().String()[:8]
+	ref := "media://" + uuid.New().String()
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	s.refToPath[ref] = localPath
+	s.refs[ref] = mediaEntry{path: localPath, meta: meta}
 	if s.scopeToRefs[scope] == nil {
 		s.scopeToRefs[scope] = make(map[string]struct{})
 	}
@@ -71,11 +80,23 @@ func (s *FileMediaStore) Resolve(ref string) (string, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	path, ok := s.refToPath[ref]
+	entry, ok := s.refs[ref]
 	if !ok {
 		return "", fmt.Errorf("media store: unknown ref: %s", ref)
 	}
-	return path, nil
+	return entry.path, nil
+}
+
+// ResolveWithMeta returns the local path and metadata for the given ref.
+func (s *FileMediaStore) ResolveWithMeta(ref string) (string, MediaMeta, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	entry, ok := s.refs[ref]
+	if !ok {
+		return "", MediaMeta{}, fmt.Errorf("media store: unknown ref: %s", ref)
+	}
+	return entry.path, entry.meta, nil
 }
 
 // ReleaseAll removes all files under the given scope and cleans up mappings.
@@ -89,11 +110,11 @@ func (s *FileMediaStore) ReleaseAll(scope string) error {
 	}
 
 	for ref := range refs {
-		if path, exists := s.refToPath[ref]; exists {
-			if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		if entry, exists := s.refs[ref]; exists {
+			if err := os.Remove(entry.path); err != nil && !os.IsNotExist(err) {
 				// Log but continue — best effort cleanup
 			}
-			delete(s.refToPath, ref)
+			delete(s.refs, ref)
 		}
 	}
 
diff --git a/pkg/media/store_test.go b/pkg/media/store_test.go
index 361582307..95bd1eb7a 100644
--- a/pkg/media/store_test.go
+++ b/pkg/media/store_test.go
@@ -139,6 +139,50 @@ func TestStoreNonexistentFile(t *testing.T) {
 	if err == nil {
 		t.Error("Store should fail for nonexistent file")
 	}
+	// Error message should include the underlying os error, not just "file does not exist"
+	if !strings.Contains(err.Error(), "no such file or directory") {
+		t.Errorf("Error should contain OS error detail, got: %v", err)
+	}
+}
+
+func TestResolveWithMeta(t *testing.T) {
+	dir := t.TempDir()
+	store := NewFileMediaStore()
+
+	path := createTempFile(t, dir, "image.png")
+	meta := MediaMeta{
+		Filename:    "image.png",
+		ContentType: "image/png",
+		Source:      "telegram",
+	}
+
+	ref, err := store.Store(path, meta, "scope1")
+	if err != nil {
+		t.Fatalf("Store failed: %v", err)
+	}
+
+	resolvedPath, resolvedMeta, err := store.ResolveWithMeta(ref)
+	if err != nil {
+		t.Fatalf("ResolveWithMeta failed: %v", err)
+	}
+	if resolvedPath != path {
+		t.Errorf("ResolveWithMeta path = %q, want %q", resolvedPath, path)
+	}
+	if resolvedMeta.Filename != meta.Filename {
+		t.Errorf("ResolveWithMeta Filename = %q, want %q", resolvedMeta.Filename, meta.Filename)
+	}
+	if resolvedMeta.ContentType != meta.ContentType {
+		t.Errorf("ResolveWithMeta ContentType = %q, want %q", resolvedMeta.ContentType, meta.ContentType)
+	}
+	if resolvedMeta.Source != meta.Source {
+		t.Errorf("ResolveWithMeta Source = %q, want %q", resolvedMeta.Source, meta.Source)
+	}
+
+	// Unknown ref should fail
+	_, _, err = store.ResolveWithMeta("media://nonexistent")
+	if err == nil {
+		t.Error("ResolveWithMeta should fail for unknown ref")
+	}
 }
 
 func TestConcurrentSafety(t *testing.T) {

From 3fb4469e47506df5c4539419438a4ce30e5da5a2 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 06:56:48 +0800
Subject: [PATCH 49/52] feat(identity): add unified user identity with
 canonical platform:id format

Introduce SenderInfo struct and pkg/identity package to standardize user
identification across all channels. Each channel now constructs structured
sender info (platform, platformID, canonicalID, username, displayName)
instead of ad-hoc string IDs. Allow-list matching supports all legacy
formats (numeric ID, @username, id|username) plus the new canonical
"platform:id" format. Session key resolution also handles canonical
peerIDs for backward-compatible identity link matching.
---
 pkg/bus/types.go                  |  10 ++
 pkg/channels/base.go              |  44 +++++-
 pkg/channels/base_test.go         |  88 ++++++++++++
 pkg/channels/dingtalk/dingtalk.go |  15 +-
 pkg/channels/discord/discord.go   |  26 ++--
 pkg/channels/feishu/feishu_64.go  |  13 +-
 pkg/channels/line/line.go         |  13 +-
 pkg/channels/maixcam/maixcam.go   |  12 ++
 pkg/channels/onebot/onebot.go     |  25 +++-
 pkg/channels/pico/pico.go         |  13 +-
 pkg/channels/qq/qq.go             |  23 +++
 pkg/channels/slack/slack.go       |  42 +++++-
 pkg/channels/telegram/telegram.go |  22 +--
 pkg/channels/wecom/app.go         |  10 +-
 pkg/channels/wecom/bot.go         |  14 +-
 pkg/channels/whatsapp/whatsapp.go |  16 ++-
 pkg/identity/identity.go          | 107 ++++++++++++++
 pkg/identity/identity_test.go     | 229 ++++++++++++++++++++++++++++++
 pkg/routing/session_key.go        |   9 ++
 pkg/routing/session_key_test.go   |  45 ++++++
 20 files changed, 742 insertions(+), 34 deletions(-)
 create mode 100644 pkg/identity/identity.go
 create mode 100644 pkg/identity/identity_test.go

diff --git a/pkg/bus/types.go b/pkg/bus/types.go
index 1a7a14170..7ad8f0417 100644
--- a/pkg/bus/types.go
+++ b/pkg/bus/types.go
@@ -6,9 +6,19 @@ type Peer struct {
 	ID   string `json:"id"`
 }
 
+// SenderInfo provides structured sender identity information.
+type SenderInfo struct {
+	Platform    string `json:"platform,omitempty"`     // "telegram", "discord", "slack", ...
+	PlatformID  string `json:"platform_id,omitempty"`  // raw platform ID, e.g. "123456"
+	CanonicalID string `json:"canonical_id,omitempty"` // "platform:id" format
+	Username    string `json:"username,omitempty"`     // username (e.g. @alice)
+	DisplayName string `json:"display_name,omitempty"` // display name
+}
+
 type InboundMessage struct {
 	Channel    string            `json:"channel"`
 	SenderID   string            `json:"sender_id"`
+	Sender     SenderInfo        `json:"sender"`
 	ChatID     string            `json:"chat_id"`
 	Content    string            `json:"content"`
 	Media      []string          `json:"media,omitempty"`
diff --git a/pkg/channels/base.go b/pkg/channels/base.go
index c6a5f1cdc..418933af7 100644
--- a/pkg/channels/base.go
+++ b/pkg/channels/base.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 )
@@ -20,6 +21,7 @@ type Channel interface {
 	Send(ctx context.Context, msg bus.OutboundMessage) error
 	IsRunning() bool
 	IsAllowed(senderID string) bool
+	IsAllowedSender(sender bus.SenderInfo) bool
 }
 
 // BaseChannelOption is a functional option for configuring a BaseChannel.
@@ -168,22 +170,58 @@ func (c *BaseChannel) IsAllowed(senderID string) bool {
 	return false
 }
 
+// IsAllowedSender checks whether a structured SenderInfo is permitted by the allow-list.
+// It delegates to identity.MatchAllowed for each entry, providing unified matching
+// across all legacy formats and the new canonical "platform:id" format.
+func (c *BaseChannel) IsAllowedSender(sender bus.SenderInfo) bool {
+	if len(c.allowList) == 0 {
+		return true
+	}
+
+	for _, allowed := range c.allowList {
+		if identity.MatchAllowed(sender, allowed) {
+			return true
+		}
+	}
+
+	return false
+}
+
 func (c *BaseChannel) HandleMessage(
 	ctx context.Context,
 	peer bus.Peer,
 	messageID, senderID, chatID, content string,
 	media []string,
 	metadata map[string]string,
+	senderOpts ...bus.SenderInfo,
 ) {
-	if !c.IsAllowed(senderID) {
-		return
+	// Use SenderInfo-based allow check when available, else fall back to string
+	var sender bus.SenderInfo
+	if len(senderOpts) > 0 {
+		sender = senderOpts[0]
+	}
+	if sender.CanonicalID != "" || sender.PlatformID != "" {
+		if !c.IsAllowedSender(sender) {
+			return
+		}
+	} else {
+		if !c.IsAllowed(senderID) {
+			return
+		}
+	}
+
+	// Set SenderID to canonical if available, otherwise keep the raw senderID
+	resolvedSenderID := senderID
+	if sender.CanonicalID != "" {
+		resolvedSenderID = sender.CanonicalID
 	}
 
 	scope := BuildMediaScope(c.name, chatID, messageID)
 
 	msg := bus.InboundMessage{
 		Channel:    c.name,
-		SenderID:   senderID,
+		SenderID:   resolvedSenderID,
+		Sender:     sender,
 		ChatID:     chatID,
 		Content:    content,
 		Media:      media,
diff --git a/pkg/channels/base_test.go b/pkg/channels/base_test.go
index e56ad3ee9..6132b8bf9 100644
--- a/pkg/channels/base_test.go
+++ b/pkg/channels/base_test.go
@@ -3,6 +3,7 @@ package channels
 import (
 	"testing"
 
+	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/config"
 )
 
@@ -175,3 +176,90 @@ func TestShouldRespondInGroup(t *testing.T) {
 		})
 	}
 }
+
+func TestIsAllowedSender(t *testing.T) {
+	tests := []struct {
+		name      string
+		allowList []string
+		sender    bus.SenderInfo
+		want      bool
+	}{
+		{
+			name:      "empty allowlist allows all",
+			allowList: nil,
+			sender:    bus.SenderInfo{PlatformID: "anyone"},
+			want:      true,
+		},
+		{
+			name:      "numeric ID matches PlatformID",
+			allowList: []string{"123456"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+			},
+			want: true,
+		},
+		{
+			name:      "canonical format matches",
+			allowList: []string{"telegram:123456"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+			},
+			want: true,
+		},
+		{
+			name:      "canonical format wrong platform",
+			allowList: []string{"discord:123456"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+			},
+			want: false,
+		},
+		{
+			name:      "@username matches",
+			allowList: []string{"@alice"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+				Username:    "alice",
+			},
+			want: true,
+		},
+		{
+			name:      "compound id|username matches by ID",
+			allowList: []string{"123456|alice"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+				Username:    "alice",
+			},
+			want: true,
+		},
+		{
+			name:      "non matching sender denied",
+			allowList: []string{"654321"},
+			sender: bus.SenderInfo{
+				Platform:    "telegram",
+				PlatformID:  "123456",
+				CanonicalID: "telegram:123456",
+			},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ch := NewBaseChannel("test", nil, nil, tt.allowList)
+			if got := ch.IsAllowedSender(tt.sender); got != tt.want {
+				t.Fatalf("IsAllowedSender(%+v) = %v, want %v", tt.sender, got, tt.want)
+			}
+		})
+	}
+}
diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go
index 7ab73b4d3..7a3aaca78 100644
--- a/pkg/channels/dingtalk/dingtalk.go
+++ b/pkg/channels/dingtalk/dingtalk.go
@@ -14,6 +14,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
@@ -182,8 +183,20 @@ func (c *DingTalkChannel) onChatBotMessageReceived(
 		"preview":     utils.Truncate(content, 50),
 	})
 
+	// Build sender info
+	sender := bus.SenderInfo{
+		Platform:    "dingtalk",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("dingtalk", senderID),
+		DisplayName: senderNick,
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return nil, nil
+	}
+
 	// Handle the message through the base channel
-	c.HandleMessage(ctx, peer, "", senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, "", senderID, chatID, content, nil, metadata, sender)
 
 	// Return nil to indicate we've handled the message asynchronously
 	// The response will be sent through the message bus
diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go
index 464a4db7b..dc49e7413 100644
--- a/pkg/channels/discord/discord.go
+++ b/pkg/channels/discord/discord.go
@@ -13,6 +13,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -263,7 +264,20 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 	}
 
 	// Check allowlist first to avoid downloading attachments for rejected users
-	if !c.IsAllowed(m.Author.ID) {
+	sender := bus.SenderInfo{
+		Platform:    "discord",
+		PlatformID:  m.Author.ID,
+		CanonicalID: identity.BuildCanonicalID("discord", m.Author.ID),
+		Username:    m.Author.Username,
+	}
+	// Build display name
+	displayName := m.Author.Username
+	if m.Author.Discriminator != "" && m.Author.Discriminator != "0" {
+		displayName += "#" + m.Author.Discriminator
+	}
+	sender.DisplayName = displayName
+
+	if !c.IsAllowedSender(sender) {
 		logger.DebugCF("discord", "Message rejected by allowlist", map[string]any{
 			"user_id": m.Author.ID,
 		})
@@ -297,10 +311,6 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 	}
 
 	senderID := m.Author.ID
-	senderName := m.Author.Username
-	if m.Author.Discriminator != "" && m.Author.Discriminator != "0" {
-		senderName += "#" + m.Author.Discriminator
-	}
 
 	mediaPaths := make([]string, 0, len(m.Attachments))
 
@@ -358,7 +368,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 	}
 
 	logger.DebugCF("discord", "Received message", map[string]any{
-		"sender_name": senderName,
+		"sender_name": sender.DisplayName,
 		"sender_id":   senderID,
 		"preview":     utils.Truncate(content, 50),
 	})
@@ -375,13 +385,13 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 	metadata := map[string]string{
 		"user_id":      senderID,
 		"username":     m.Author.Username,
-		"display_name": senderName,
+		"display_name": sender.DisplayName,
 		"guild_id":     m.GuildID,
 		"channel_id":   m.ChannelID,
 		"is_dm":        fmt.Sprintf("%t", m.GuildID == ""),
 	}
 
-	c.HandleMessage(c.ctx, peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata, sender)
 }
 
 // startTyping starts a continuous typing indicator loop for the given chatID.
diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go
index 4b8eddd21..62bf69486 100644
--- a/pkg/channels/feishu/feishu_64.go
+++ b/pkg/channels/feishu/feishu_64.go
@@ -17,6 +17,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
@@ -189,7 +190,17 @@ func (c *FeishuChannel) handleMessageReceive(ctx context.Context, event *larkim.
 		"preview":   utils.Truncate(content, 80),
 	})
 
-	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata)
+	senderInfo := bus.SenderInfo{
+		Platform:    "feishu",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("feishu", senderID),
+	}
+
+	if !c.IsAllowedSender(senderInfo) {
+		return nil
+	}
+
+	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata, senderInfo)
 	return nil
 }
 
diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go
index 399617064..28d5ad8f7 100644
--- a/pkg/channels/line/line.go
+++ b/pkg/channels/line/line.go
@@ -17,6 +17,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -370,7 +371,17 @@ func (c *LINEChannel) processEvent(event lineEvent) {
 	// Show typing/loading indicator (requires user ID, not group ID)
 	c.sendLoading(senderID)
 
-	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, mediaPaths, metadata)
+	sender := bus.SenderInfo{
+		Platform:    "line",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("line", senderID),
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return
+	}
+
+	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, mediaPaths, metadata, sender)
 }
 
 // isBotMentioned checks if the bot is mentioned in the message.
diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go
index dceaec4c5..142a4b7e7 100644
--- a/pkg/channels/maixcam/maixcam.go
+++ b/pkg/channels/maixcam/maixcam.go
@@ -11,6 +11,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
@@ -179,6 +180,16 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
 		"h":         fmt.Sprintf("%.0f", h),
 	}
 
+	sender := bus.SenderInfo{
+		Platform:    "maixcam",
+		PlatformID:  "maixcam",
+		CanonicalID: identity.BuildCanonicalID("maixcam", "maixcam"),
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return
+	}
+
 	c.HandleMessage(
 		c.ctx,
 		bus.Peer{Kind: "channel", ID: "default"},
@@ -188,6 +199,7 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) {
 		content,
 		[]string{},
 		metadata,
+		sender,
 	)
 }
 
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index b47685397..a748acaa0 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -15,6 +15,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -823,7 +824,13 @@ func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
 	switch raw.PostType {
 	case "message":
 		if userID, err := parseJSONInt64(raw.UserID); err == nil && userID > 0 {
-			if !c.IsAllowed(strconv.FormatInt(userID, 10)) {
+			// Build minimal sender for allowlist check
+			sender := bus.SenderInfo{
+				Platform:    "onebot",
+				PlatformID:  strconv.FormatInt(userID, 10),
+				CanonicalID: identity.BuildCanonicalID("onebot", strconv.FormatInt(userID, 10)),
+			}
+			if !c.IsAllowedSender(sender) {
 				logger.DebugCF("onebot", "Message rejected by allowlist", map[string]any{
 					"user_id": userID,
 				})
@@ -1040,7 +1047,21 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) {
 		}
 	}
 
-	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, parsed.Media, metadata)
+	senderInfo := bus.SenderInfo{
+		Platform:    "onebot",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("onebot", senderID),
+		DisplayName: sender.Nickname,
+	}
+
+	if !c.IsAllowedSender(senderInfo) {
+		logger.DebugCF("onebot", "Message rejected by allowlist (senderInfo)", map[string]any{
+			"sender": senderID,
+		})
+		return
+	}
+
+	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, parsed.Media, metadata, senderInfo)
 }
 
 func (c *OneBotChannel) isDuplicate(messageID string) bool {
diff --git a/pkg/channels/pico/pico.go b/pkg/channels/pico/pico.go
index 9809786e3..c646a3b0b 100644
--- a/pkg/channels/pico/pico.go
+++ b/pkg/channels/pico/pico.go
@@ -16,6 +16,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
@@ -420,7 +421,17 @@ func (c *PicoChannel) handleMessageSend(pc *picoConn, msg PicoMessage) {
 		}
 	}
 
-	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, nil, metadata)
+	sender := bus.SenderInfo{
+		Platform:    "pico",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("pico", senderID),
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return
+	}
+
+	c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, nil, metadata, sender)
 }
 
 // truncate truncates a string to maxLen runes.
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index c43c13655..85313efe5 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -16,6 +16,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
@@ -168,6 +169,16 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 		// 转发到消息总线
 		metadata := map[string]string{}
 
+		sender := bus.SenderInfo{
+			Platform:    "qq",
+			PlatformID:  data.Author.ID,
+			CanonicalID: identity.BuildCanonicalID("qq", data.Author.ID),
+		}
+
+		if !c.IsAllowedSender(sender) {
+			return nil
+		}
+
 		c.HandleMessage(c.ctx,
 			bus.Peer{Kind: "direct", ID: senderID},
 			data.ID,
@@ -176,6 +187,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 			content,
 			[]string{},
 			metadata,
+			sender,
 		)
 
 		return nil
@@ -224,6 +236,16 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			"group_id": data.GroupID,
 		}
 
+		sender := bus.SenderInfo{
+			Platform:    "qq",
+			PlatformID:  data.Author.ID,
+			CanonicalID: identity.BuildCanonicalID("qq", data.Author.ID),
+		}
+
+		if !c.IsAllowedSender(sender) {
+			return nil
+		}
+
 		c.HandleMessage(c.ctx,
 			bus.Peer{Kind: "group", ID: data.GroupID},
 			data.ID,
@@ -232,6 +254,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			content,
 			[]string{},
 			metadata,
+			sender,
 		)
 
 		return nil
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index c6b3c829e..90c4297ca 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -13,6 +13,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -252,7 +253,12 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 	}
 
 	// 检查白名单，避免为被拒绝的用户下载附件
-	if !c.IsAllowed(ev.User) {
+	sender := bus.SenderInfo{
+		Platform:    "slack",
+		PlatformID:  ev.User,
+		CanonicalID: identity.BuildCanonicalID("slack", ev.User),
+	}
+	if !c.IsAllowedSender(sender) {
 		logger.DebugCF("slack", "Message rejected by allowlist", map[string]any{
 			"user_id": ev.User,
 		})
@@ -360,7 +366,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		"has_thread": threadTS != "",
 	})
 
-	c.HandleMessage(c.ctx, peer, messageTS, senderID, chatID, content, mediaPaths, metadata)
+	c.HandleMessage(c.ctx, peer, messageTS, senderID, chatID, content, mediaPaths, metadata, sender)
 }
 
 func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
@@ -368,7 +374,11 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		return
 	}
 
-	if !c.IsAllowed(ev.User) {
+	if !c.IsAllowedSender(bus.SenderInfo{
+		Platform:    "slack",
+		PlatformID:  ev.User,
+		CanonicalID: identity.BuildCanonicalID("slack", ev.User),
+	}) {
 		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]any{
 			"user_id": ev.User,
 		})
@@ -376,6 +386,11 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 	}
 
 	senderID := ev.User
+	mentionSender := bus.SenderInfo{
+		Platform:    "slack",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("slack", senderID),
+	}
 	channelID := ev.Channel
 	threadTS := ev.ThreadTimeStamp
 	messageTS := ev.TimeStamp
@@ -433,7 +448,7 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		"team_id":    c.teamID,
 	}
 
-	c.HandleMessage(c.ctx, mentionPeer, messageTS, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(c.ctx, mentionPeer, messageTS, senderID, chatID, content, nil, metadata, mentionSender)
 }
 
 func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
@@ -446,7 +461,12 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		c.socketClient.Ack(*event.Request)
 	}
 
-	if !c.IsAllowed(cmd.UserID) {
+	cmdSender := bus.SenderInfo{
+		Platform:    "slack",
+		PlatformID:  cmd.UserID,
+		CanonicalID: identity.BuildCanonicalID("slack", cmd.UserID),
+	}
+	if !c.IsAllowedSender(cmdSender) {
 		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]any{
 			"user_id": cmd.UserID,
 		})
@@ -476,7 +496,17 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		"text":      utils.Truncate(content, 50),
 	})
 
-	c.HandleMessage(c.ctx, bus.Peer{Kind: "channel", ID: channelID}, "", senderID, chatID, content, nil, metadata)
+	c.HandleMessage(
+		c.ctx,
+		bus.Peer{Kind: "channel", ID: channelID},
+		"",
+		senderID,
+		chatID,
+		content,
+		nil,
+		metadata,
+		cmdSender,
+	)
 }
 
 func (c *SlackChannel) downloadSlackFile(file slack.File) string {
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 31be4d489..6b5a84eda 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -19,6 +19,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/media"
 	"github.com/sipeed/picoclaw/pkg/utils"
@@ -289,21 +290,25 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		return fmt.Errorf("message sender (user) is nil")
 	}
 
-	senderID := fmt.Sprintf("%d", user.ID)
-	if user.Username != "" {
-		senderID = fmt.Sprintf("%d|%s", user.ID, user.Username)
+	platformID := fmt.Sprintf("%d", user.ID)
+	sender := bus.SenderInfo{
+		Platform:    "telegram",
+		PlatformID:  platformID,
+		CanonicalID: identity.BuildCanonicalID("telegram", platformID),
+		Username:    user.Username,
+		DisplayName: user.FirstName,
 	}
 
 	// 检查白名单，避免为被拒绝的用户下载附件
-	if !c.IsAllowed(senderID) {
+	if !c.IsAllowedSender(sender) {
 		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]any{
-			"user_id": senderID,
+			"user_id": platformID,
 		})
 		return nil
 	}
 
 	chatID := message.Chat.ID
-	c.chatIDs[senderID] = chatID
+	c.chatIDs[platformID] = chatID
 
 	content := ""
 	mediaPaths := []string{}
@@ -401,7 +406,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	}
 
 	logger.DebugCF("telegram", "Received message", map[string]any{
-		"sender_id": senderID,
+		"sender_id": sender.CanonicalID,
 		"chat_id":   fmt.Sprintf("%d", chatID),
 		"preview":   utils.Truncate(content, 50),
 	})
@@ -451,11 +456,12 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 	c.HandleMessage(c.ctx,
 		peer,
 		messageID,
-		fmt.Sprintf("%d", user.ID),
+		platformID,
 		fmt.Sprintf("%d", chatID),
 		content,
 		mediaPaths,
 		metadata,
+		sender,
 	)
 	return nil
 }
diff --git a/pkg/channels/wecom/app.go b/pkg/channels/wecom/app.go
index e822e67b2..f1e764864 100644
--- a/pkg/channels/wecom/app.go
+++ b/pkg/channels/wecom/app.go
@@ -19,6 +19,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
@@ -629,8 +630,15 @@ func (c *WeComAppChannel) processMessage(ctx context.Context, msg WeComXMLMessag
 		"preview":   utils.Truncate(content, 50),
 	})
 
+	// Build sender info
+	appSender := bus.SenderInfo{
+		Platform:    "wecom",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("wecom", senderID),
+	}
+
 	// Handle the message through the base channel
-	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, nil, metadata, appSender)
 }
 
 // tokenRefreshLoop periodically refreshes the access token
diff --git a/pkg/channels/wecom/bot.go b/pkg/channels/wecom/bot.go
index 401c9c5ec..460997dab 100644
--- a/pkg/channels/wecom/bot.go
+++ b/pkg/channels/wecom/bot.go
@@ -15,6 +15,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
@@ -398,8 +399,19 @@ func (c *WeComBotChannel) processMessage(ctx context.Context, msg WeComBotMessag
 		"preview":       utils.Truncate(content, 50),
 	})
 
+	// Build sender info
+	sender := bus.SenderInfo{
+		Platform:    "wecom",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("wecom", senderID),
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return
+	}
+
 	// Handle the message through the base channel
-	c.HandleMessage(ctx, peer, msg.MsgID, senderID, chatID, content, nil, metadata)
+	c.HandleMessage(ctx, peer, msg.MsgID, senderID, chatID, content, nil, metadata, sender)
 }
 
 // sendWebhookReply sends a reply using the webhook URL
diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go
index b4599b5a0..106114090 100644
--- a/pkg/channels/whatsapp/whatsapp.go
+++ b/pkg/channels/whatsapp/whatsapp.go
@@ -12,6 +12,7 @@ import (
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
 	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/identity"
 	"github.com/sipeed/picoclaw/pkg/logger"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
@@ -224,5 +225,18 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) {
 		"preview": utils.Truncate(content, 50),
 	})
 
-	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, mediaPaths, metadata)
+	sender := bus.SenderInfo{
+		Platform:    "whatsapp",
+		PlatformID:  senderID,
+		CanonicalID: identity.BuildCanonicalID("whatsapp", senderID),
+	}
+	if display, ok := metadata["user_name"]; ok {
+		sender.DisplayName = display
+	}
+
+	if !c.IsAllowedSender(sender) {
+		return
+	}
+
+	c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, mediaPaths, metadata, sender)
 }
diff --git a/pkg/identity/identity.go b/pkg/identity/identity.go
new file mode 100644
index 000000000..6bc09c210
--- /dev/null
+++ b/pkg/identity/identity.go
@@ -0,0 +1,107 @@
+// Package identity provides unified user identity utilities for PicoClaw.
+// It introduces a canonical "platform:id" format and matching logic
+// that is backward-compatible with all legacy allow-list formats.
+package identity
+
+import (
+	"strings"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+)
+
+// BuildCanonicalID constructs a canonical "platform:id" identifier.
+// Both platform and platformID are lowercased and trimmed.
+func BuildCanonicalID(platform, platformID string) string {
+	p := strings.ToLower(strings.TrimSpace(platform))
+	id := strings.TrimSpace(platformID)
+	if p == "" || id == "" {
+		return ""
+	}
+	return p + ":" + id
+}
+
+// ParseCanonicalID splits a canonical ID ("platform:id") into its parts.
+// Returns ok=false if the input does not contain a colon separator.
+func ParseCanonicalID(canonical string) (platform, id string, ok bool) {
+	canonical = strings.TrimSpace(canonical)
+	idx := strings.Index(canonical, ":")
+	if idx <= 0 || idx == len(canonical)-1 {
+		return "", "", false
+	}
+	return canonical[:idx], canonical[idx+1:], true
+}
+
+// MatchAllowed checks whether the given sender matches a single allow-list entry.
+// It is backward-compatible with all legacy formats:
+//
+//   - "123456"              → matches sender.PlatformID
+//   - "@alice"              → matches sender.Username
+//   - "123456|alice"        → matches PlatformID or Username
+//   - "telegram:123456"     → exact match on sender.CanonicalID
+func MatchAllowed(sender bus.SenderInfo, allowed string) bool {
+	allowed = strings.TrimSpace(allowed)
+	if allowed == "" {
+		return false
+	}
+
+	// Try canonical match first: "platform:id" format
+	if platform, id, ok := ParseCanonicalID(allowed); ok {
+		// Only treat as canonical if the platform portion looks like a known platform name
+		// (not a pure-numeric string, which could be a compound ID)
+		if !isNumeric(platform) {
+			candidate := BuildCanonicalID(platform, id)
+			if candidate != "" && sender.CanonicalID != "" {
+				return strings.EqualFold(sender.CanonicalID, candidate)
+			}
+			// If sender has no canonical ID, try matching platform + platformID
+			return strings.EqualFold(platform, sender.Platform) &&
+				sender.PlatformID == id
+		}
+	}
+
+	// Strip leading "@" for username matching
+	trimmed := strings.TrimPrefix(allowed, "@")
+
+	// Split compound "id|username" format
+	allowedID := trimmed
+	allowedUser := ""
+	if idx := strings.Index(trimmed, "|"); idx > 0 {
+		allowedID = trimmed[:idx]
+		allowedUser = trimmed[idx+1:]
+	}
+
+	// Match against PlatformID
+	if sender.PlatformID != "" && sender.PlatformID == allowedID {
+		return true
+	}
+
+	// Match against Username
+	if sender.Username != "" {
+		if sender.Username == trimmed || sender.Username == allowedUser {
+			return true
+		}
+	}
+
+	// Match compound sender format against allowed parts
+	if allowedUser != "" && sender.PlatformID != "" && sender.PlatformID == allowedID {
+		return true
+	}
+	if allowedUser != "" && sender.Username != "" && sender.Username == allowedUser {
+		return true
+	}
+
+	return false
+}
+
+// isNumeric returns true if s consists entirely of digits.
+func isNumeric(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	return true
+}
diff --git a/pkg/identity/identity_test.go b/pkg/identity/identity_test.go
new file mode 100644
index 000000000..3d24bd794
--- /dev/null
+++ b/pkg/identity/identity_test.go
@@ -0,0 +1,229 @@
+package identity
+
+import (
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+)
+
+func TestBuildCanonicalID(t *testing.T) {
+	tests := []struct {
+		platform   string
+		platformID string
+		want       string
+	}{
+		{"telegram", "123456", "telegram:123456"},
+		{"Discord", "98765432", "discord:98765432"},
+		{"SLACK", "U123ABC", "slack:U123ABC"},
+		{"", "123", ""},
+		{"telegram", "", ""},
+		{"  telegram  ", "  123  ", "telegram:123"},
+	}
+
+	for _, tt := range tests {
+		got := BuildCanonicalID(tt.platform, tt.platformID)
+		if got != tt.want {
+			t.Errorf("BuildCanonicalID(%q, %q) = %q, want %q",
+				tt.platform, tt.platformID, got, tt.want)
+		}
+	}
+}
+
+func TestParseCanonicalID(t *testing.T) {
+	tests := []struct {
+		input        string
+		wantPlatform string
+		wantID       string
+		wantOk       bool
+	}{
+		{"telegram:123456", "telegram", "123456", true},
+		{"discord:98765432", "discord", "98765432", true},
+		{"slack:U123ABC", "slack", "U123ABC", true},
+		{"nocolon", "", "", false},
+		{"", "", "", false},
+		{":missing", "", "", false},
+		{"missing:", "", "", false},
+	}
+
+	for _, tt := range tests {
+		platform, id, ok := ParseCanonicalID(tt.input)
+		if ok != tt.wantOk || platform != tt.wantPlatform || id != tt.wantID {
+			t.Errorf("ParseCanonicalID(%q) = (%q, %q, %v), want (%q, %q, %v)",
+				tt.input, platform, id, ok,
+				tt.wantPlatform, tt.wantID, tt.wantOk)
+		}
+	}
+}
+
+func TestMatchAllowed(t *testing.T) {
+	telegramSender := bus.SenderInfo{
+		Platform:    "telegram",
+		PlatformID:  "123456",
+		CanonicalID: "telegram:123456",
+		Username:    "alice",
+		DisplayName: "Alice Smith",
+	}
+
+	discordSender := bus.SenderInfo{
+		Platform:    "discord",
+		PlatformID:  "98765432",
+		CanonicalID: "discord:98765432",
+		Username:    "bob",
+		DisplayName: "bob#1234",
+	}
+
+	noCanonicalSender := bus.SenderInfo{
+		Platform:   "telegram",
+		PlatformID: "999",
+		Username:   "carol",
+	}
+
+	tests := []struct {
+		name    string
+		sender  bus.SenderInfo
+		allowed string
+		want    bool
+	}{
+		// Pure numeric ID matching
+		{
+			name:    "numeric ID matches PlatformID",
+			sender:  telegramSender,
+			allowed: "123456",
+			want:    true,
+		},
+		{
+			name:    "numeric ID does not match",
+			sender:  telegramSender,
+			allowed: "654321",
+			want:    false,
+		},
+		// Username matching
+		{
+			name:    "@username matches Username",
+			sender:  telegramSender,
+			allowed: "@alice",
+			want:    true,
+		},
+		{
+			name:    "@username does not match",
+			sender:  telegramSender,
+			allowed: "@bob",
+			want:    false,
+		},
+		// Compound format "id|username"
+		{
+			name:    "compound matches by ID",
+			sender:  telegramSender,
+			allowed: "123456|alice",
+			want:    true,
+		},
+		{
+			name:    "compound matches by username",
+			sender:  telegramSender,
+			allowed: "999|alice",
+			want:    true,
+		},
+		{
+			name:    "compound does not match",
+			sender:  telegramSender,
+			allowed: "654321|bob",
+			want:    false,
+		},
+		// Canonical format "platform:id"
+		{
+			name:    "canonical matches exactly",
+			sender:  telegramSender,
+			allowed: "telegram:123456",
+			want:    true,
+		},
+		{
+			name:    "canonical case-insensitive platform",
+			sender:  telegramSender,
+			allowed: "Telegram:123456",
+			want:    true,
+		},
+		{
+			name:    "canonical wrong platform",
+			sender:  telegramSender,
+			allowed: "discord:123456",
+			want:    false,
+		},
+		{
+			name:    "canonical wrong ID",
+			sender:  telegramSender,
+			allowed: "telegram:654321",
+			want:    false,
+		},
+		// Cross-platform canonical
+		{
+			name:    "discord canonical match",
+			sender:  discordSender,
+			allowed: "discord:98765432",
+			want:    true,
+		},
+		{
+			name:    "telegram canonical does not match discord sender",
+			sender:  discordSender,
+			allowed: "telegram:98765432",
+			want:    false,
+		},
+		// Sender without canonical ID
+		{
+			name:    "canonical match falls back to platform+platformID",
+			sender:  noCanonicalSender,
+			allowed: "telegram:999",
+			want:    true,
+		},
+		{
+			name:    "platform mismatch on fallback",
+			sender:  noCanonicalSender,
+			allowed: "discord:999",
+			want:    false,
+		},
+		// Empty allowed string
+		{
+			name:    "empty allowed never matches",
+			sender:  telegramSender,
+			allowed: "",
+			want:    false,
+		},
+		// Whitespace handling
+		{
+			name:    "trimmed allowed matches",
+			sender:  telegramSender,
+			allowed: "  123456  ",
+			want:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := MatchAllowed(tt.sender, tt.allowed)
+			if got != tt.want {
+				t.Errorf("MatchAllowed(%+v, %q) = %v, want %v",
+					tt.sender, tt.allowed, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIsNumeric(t *testing.T) {
+	tests := []struct {
+		input string
+		want  bool
+	}{
+		{"123456", true},
+		{"0", true},
+		{"", false},
+		{"abc", false},
+		{"12a34", false},
+		{"telegram", false},
+	}
+
+	for _, tt := range tests {
+		got := isNumeric(tt.input)
+		if got != tt.want {
+			t.Errorf("isNumeric(%q) = %v, want %v", tt.input, got, tt.want)
+		}
+	}
+}
diff --git a/pkg/routing/session_key.go b/pkg/routing/session_key.go
index e12f0d1d8..eab592bec 100644
--- a/pkg/routing/session_key.go
+++ b/pkg/routing/session_key.go
@@ -163,6 +163,15 @@ func resolveLinkedPeerID(identityLinks map[string][]string, channel, peerID stri
 		scopedCandidate := fmt.Sprintf("%s:%s", channel, strings.ToLower(peerID))
 		candidates[scopedCandidate] = true
 	}
+
+	// If peerID is already in canonical "platform:id" format, also add the
+	// bare ID part as a candidate for backward compatibility with identity_links
+	// that use raw IDs (e.g. "123" instead of "telegram:123").
+	if idx := strings.Index(rawCandidate, ":"); idx > 0 && idx < len(rawCandidate)-1 {
+		bareID := rawCandidate[idx+1:]
+		candidates[bareID] = true
+	}
+
 	if len(candidates) == 0 {
 		return ""
 	}
diff --git a/pkg/routing/session_key_test.go b/pkg/routing/session_key_test.go
index 81e4ce018..ad7a1ca02 100644
--- a/pkg/routing/session_key_test.go
+++ b/pkg/routing/session_key_test.go
@@ -115,6 +115,51 @@ func TestBuildAgentPeerSessionKey_IdentityLink(t *testing.T) {
 	}
 }
 
+func TestResolveLinkedPeerID_CanonicalPeerID(t *testing.T) {
+	// When peerID is already in canonical "platform:id" format,
+	// it should match identity_links that use the bare ID.
+	links := map[string][]string{
+		"john": {"123"},
+	}
+	got := resolveLinkedPeerID(links, "telegram", "telegram:123")
+	if got != "john" {
+		t.Errorf("resolveLinkedPeerID with canonical peerID = %q, want %q", got, "john")
+	}
+}
+
+func TestResolveLinkedPeerID_CanonicalInLinks(t *testing.T) {
+	// When identity_links contain canonical IDs and peerID is canonical too
+	links := map[string][]string{
+		"john": {"telegram:123", "discord:456"},
+	}
+	got := resolveLinkedPeerID(links, "telegram", "telegram:123")
+	if got != "john" {
+		t.Errorf("resolveLinkedPeerID canonical in links = %q, want %q", got, "john")
+	}
+}
+
+func TestResolveLinkedPeerID_BarePeerIDMatchesCanonicalLink(t *testing.T) {
+	// When peerID is bare "123" and links have "telegram:123",
+	// the scoped candidate "telegram:123" should match.
+	links := map[string][]string{
+		"john": {"telegram:123"},
+	}
+	got := resolveLinkedPeerID(links, "telegram", "123")
+	if got != "john" {
+		t.Errorf("resolveLinkedPeerID bare peer matches canonical link = %q, want %q", got, "john")
+	}
+}
+
+func TestResolveLinkedPeerID_NoMatch(t *testing.T) {
+	links := map[string][]string{
+		"john": {"telegram:123"},
+	}
+	got := resolveLinkedPeerID(links, "discord", "999")
+	if got != "" {
+		t.Errorf("resolveLinkedPeerID no match = %q, want empty", got)
+	}
+}
+
 func TestParseAgentSessionKey_Valid(t *testing.T) {
 	parsed := ParseAgentSessionKey("agent:sales:telegram:direct:user123")
 	if parsed == nil {

From cea0b95f07a54db6078a4e8f7109c3cb9d02edfb Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 08:20:15 +0800
Subject: [PATCH 50/52] refactor(loop): disable media cleanup to prevent
 premature file deletion

---
 pkg/agent/loop.go | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 0e2097488..773e8acd5 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -170,18 +170,20 @@ func (al *AgentLoop) Run(ctx context.Context) error {
 				continue
 			}
 
-			// Process message and ensure media is released afterward
+			// Process message
 			func() {
-				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(),
-							})
-						}
-					}
-				}()
+				// 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 {

From 94f59fbcab4b0785a76bb2beb987fc2819156da5 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Mon, 23 Feb 2026 21:34:37 +0800
Subject: [PATCH 51/52] fix: address PR #662 review comments (bus drain,
 context timeouts, onebot leak)

- Drain buffered messages in MessageBus.Close() so they aren't silently lost
- Replace all context.TODO() with context.WithTimeout(5s) across 7 call sites
- Fix OneBot pending channel leak: send nil sentinel in Stop() and handle
  nil response in sendAPIRequest() to unblock waiting goroutines
---
 pkg/agent/loop.go             |  9 ++++++---
 pkg/bus/bus.go                | 38 +++++++++++++++++++++++++++++++++++
 pkg/channels/onebot/onebot.go |  9 ++++++++-
 pkg/devices/service.go        |  5 ++++-
 pkg/heartbeat/service.go      |  4 +++-
 pkg/tools/cron.go             |  8 ++++++--
 pkg/tools/subagent.go         |  4 +++-
 7 files changed, 68 insertions(+), 9 deletions(-)

diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 773e8acd5..088e8c4d2 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -121,12 +121,13 @@ func registerSharedTools(
 		// Message tool
 		messageTool := tools.NewMessageTool()
 		messageTool.SetSendCallback(func(channel, chatID, content string) error {
-			msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+			pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer pubCancel()
+			return msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
 				Channel: channel,
 				ChatID:  chatID,
 				Content: content,
 			})
-			return nil
 		})
 		agent.Tools.Register(messageTool)
 
@@ -835,7 +836,9 @@ func (al *AgentLoop) maybeSummarize(agent *AgentInstance, sessionKey, channel, c
 			go func() {
 				defer al.summarizing.Delete(summarizeKey)
 				if !constants.IsInternalChannel(channel) {
-					al.bus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+					pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+					defer pubCancel()
+					al.bus.PublishOutbound(pubCtx, bus.OutboundMessage{
 						Channel: channel,
 						ChatID:  chatID,
 						Content: "Memory threshold reached. Optimizing conversation history...",
diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go
index 6a1c987b7..d2b6838c5 100644
--- a/pkg/bus/bus.go
+++ b/pkg/bus/bus.go
@@ -4,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"sync/atomic"
+
+	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
 // ErrBusClosed is returned when publishing to a closed MessageBus.
@@ -104,5 +106,41 @@ func (mb *MessageBus) SubscribeOutboundMedia(ctx context.Context) (OutboundMedia
 func (mb *MessageBus) Close() {
 	if mb.closed.CompareAndSwap(false, true) {
 		close(mb.done)
+
+		// Drain buffered channels so messages aren't silently lost.
+		// Channels are NOT closed to avoid send-on-closed panics from concurrent publishers.
+		drained := 0
+		for {
+			select {
+			case <-mb.inbound:
+				drained++
+			default:
+				goto doneInbound
+			}
+		}
+	doneInbound:
+		for {
+			select {
+			case <-mb.outbound:
+				drained++
+			default:
+				goto doneOutbound
+			}
+		}
+	doneOutbound:
+		for {
+			select {
+			case <-mb.outboundMedia:
+				drained++
+			default:
+				goto doneMedia
+			}
+		}
+	doneMedia:
+		if drained > 0 {
+			logger.DebugCF("bus", "Drained buffered messages during close", map[string]any{
+				"count": drained,
+			})
+		}
 	}
 }
diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go
index a748acaa0..feb198d7d 100644
--- a/pkg/channels/onebot/onebot.go
+++ b/pkg/channels/onebot/onebot.go
@@ -306,6 +306,9 @@ func (c *OneBotChannel) sendAPIRequest(action string, params any, timeout time.D
 
 	select {
 	case resp := <-ch:
+		if resp == nil {
+			return nil, fmt.Errorf("API request %s: channel stopped", action)
+		}
 		return resp, nil
 	case <-time.After(timeout):
 		return nil, fmt.Errorf("API request %s timed out after %v", action, timeout)
@@ -353,7 +356,11 @@ func (c *OneBotChannel) Stop(ctx context.Context) error {
 	}
 
 	c.pendingMu.Lock()
-	for echo := range c.pending {
+	for echo, ch := range c.pending {
+		select {
+		case ch <- nil: // non-blocking wake for blocked sendAPIRequest goroutines
+		default:
+		}
 		delete(c.pending, echo)
 	}
 	c.pendingMu.Unlock()
diff --git a/pkg/devices/service.go b/pkg/devices/service.go
index 408e1c8aa..1bafe6085 100644
--- a/pkg/devices/service.go
+++ b/pkg/devices/service.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/constants"
@@ -127,7 +128,9 @@ func (s *Service) sendNotification(ev *events.DeviceEvent) {
 	}
 
 	msg := ev.FormatMessage()
-	msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+	pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer pubCancel()
+	msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
 		Channel: platform,
 		ChatID:  userID,
 		Content: msg,
diff --git a/pkg/heartbeat/service.go b/pkg/heartbeat/service.go
index 62b321955..475f10509 100644
--- a/pkg/heartbeat/service.go
+++ b/pkg/heartbeat/service.go
@@ -308,7 +308,9 @@ func (hs *HeartbeatService) sendResponse(response string) {
 		return
 	}
 
-	msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+	pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer pubCancel()
+	msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
 		Channel: platform,
 		ChatID:  userID,
 		Content: response,
diff --git a/pkg/tools/cron.go b/pkg/tools/cron.go
index 3c13f5968..52f914622 100644
--- a/pkg/tools/cron.go
+++ b/pkg/tools/cron.go
@@ -294,7 +294,9 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string {
 			output = fmt.Sprintf("Scheduled command '%s' executed:\n%s", job.Payload.Command, result.ForLLM)
 		}
 
-		t.msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+		pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer pubCancel()
+		t.msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
 			Channel: channel,
 			ChatID:  chatID,
 			Content: output,
@@ -304,7 +306,9 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string {
 
 	// If deliver=true, send message directly without agent processing
 	if job.Payload.Deliver {
-		t.msgBus.PublishOutbound(context.TODO(), bus.OutboundMessage{
+		pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer pubCancel()
+		t.msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{
 			Channel: channel,
 			ChatID:  chatID,
 			Content: job.Payload.Message,
diff --git a/pkg/tools/subagent.go b/pkg/tools/subagent.go
index 99821daf9..fee53fc28 100644
--- a/pkg/tools/subagent.go
+++ b/pkg/tools/subagent.go
@@ -218,7 +218,9 @@ After completing the task, provide a clear summary of what was done.`
 	// Send announce message back to main agent
 	if sm.bus != nil {
 		announceContent := fmt.Sprintf("Task '%s' completed.\n\nResult:\n%s", task.Label, task.Result)
-		sm.bus.PublishInbound(context.TODO(), bus.InboundMessage{
+		pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer pubCancel()
+		sm.bus.PublishInbound(pubCtx, bus.InboundMessage{
 			Channel:  "system",
 			SenderID: fmt.Sprintf("subagent:%s", task.ID),
 			// Format: "original_channel:original_chat_id" for routing back

From 692efb21287cd6fde4bc53e011a5dbde9706ef58 Mon Sep 17 00:00:00 2001
From: Hoshina <hoshina@evaz.org>
Date: Tue, 24 Feb 2026 12:17:11 +0800
Subject: [PATCH 52/52] chore: apply PR #697 comment translations to refactored
 channel subpackages

Translate Chinese comments to English in qq, slack, and telegram channel
implementations, following the translation work done in PR #697. The
original PR modified the old parent package files, but these have been
moved to subpackages during the refactor, so translations are applied
to the new locations.
---
 pkg/channels/qq/qq.go             | 36 +++++++++++++++----------------
 pkg/channels/slack/slack.go       |  2 +-
 pkg/channels/telegram/telegram.go |  2 +-
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 85313efe5..1e2cc2354 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -51,31 +51,31 @@ func (c *QQChannel) Start(ctx context.Context) error {
 
 	logger.InfoC("qq", "Starting QQ bot (WebSocket mode)")
 
-	// 创建 token source
+	// create token source
 	credentials := &token.QQBotCredentials{
 		AppID:     c.config.AppID,
 		AppSecret: c.config.AppSecret,
 	}
 	c.tokenSource = token.NewQQBotTokenSource(credentials)
 
-	// 创建子 context
+	// create child context
 	c.ctx, c.cancel = context.WithCancel(ctx)
 
-	// 启动自动刷新 token 协程
+	// start auto-refresh token goroutine
 	if err := token.StartRefreshAccessToken(c.ctx, c.tokenSource); err != nil {
 		return fmt.Errorf("failed to start token refresh: %w", err)
 	}
 
-	// 初始化 OpenAPI 客户端
+	// initialize OpenAPI client
 	c.api = botgo.NewOpenAPI(c.config.AppID, c.tokenSource).WithTimeout(5 * time.Second)
 
-	// 注册事件处理器
+	// register event handlers
 	intent := event.RegisterHandlers(
 		c.handleC2CMessage(),
 		c.handleGroupATMessage(),
 	)
 
-	// 获取 WebSocket 接入点
+	// get WebSocket endpoint
 	wsInfo, err := c.api.WS(c.ctx, nil, "")
 	if err != nil {
 		return fmt.Errorf("failed to get websocket info: %w", err)
@@ -85,10 +85,10 @@ func (c *QQChannel) Start(ctx context.Context) error {
 		"shards": wsInfo.Shards,
 	})
 
-	// 创建并保存 sessionManager
+	// create and save sessionManager
 	c.sessionManager = botgo.NewSessionManager()
 
-	// 在 goroutine 中启动 WebSocket 连接，避免阻塞
+	// start WebSocket connection in goroutine to avoid blocking
 	go func() {
 		if err := c.sessionManager.Start(wsInfo, c.tokenSource, &intent); err != nil {
 			logger.ErrorCF("qq", "WebSocket session error", map[string]any{
@@ -120,12 +120,12 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 		return channels.ErrNotRunning
 	}
 
-	// 构造消息
+	// construct message
 	msgToCreate := &dto.MessageToCreate{
 		Content: msg.Content,
 	}
 
-	// C2C 消息发送
+	// send C2C message
 	_, err := c.api.PostC2CMessage(ctx, msg.ChatID, msgToCreate)
 	if err != nil {
 		logger.ErrorCF("qq", "Failed to send C2C message", map[string]any{
@@ -137,15 +137,15 @@ func (c *QQChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
 	return nil
 }
 
-// handleC2CMessage 处理 QQ 私聊消息
+// handleC2CMessage handles QQ private messages
 func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 	return func(event *dto.WSPayload, data *dto.WSC2CMessageData) error {
-		// 去重检查
+		// deduplication check
 		if c.isDuplicate(data.ID) {
 			return nil
 		}
 
-		// 提取用户信息
+		// extract user info
 		var senderID string
 		if data.Author != nil && data.Author.ID != "" {
 			senderID = data.Author.ID
@@ -154,7 +154,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 			return nil
 		}
 
-		// 提取消息内容
+		// extract message content
 		content := data.Content
 		if content == "" {
 			logger.DebugC("qq", "Received empty message, ignoring")
@@ -194,15 +194,15 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler {
 	}
 }
 
-// handleGroupATMessage 处理群@消息
+// handleGroupATMessage handles QQ group @ messages
 func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 	return func(event *dto.WSPayload, data *dto.WSGroupATMessageData) error {
-		// 去重检查
+		// deduplication check
 		if c.isDuplicate(data.ID) {
 			return nil
 		}
 
-		// 提取用户信息
+		// extract user info
 		var senderID string
 		if data.Author != nil && data.Author.ID != "" {
 			senderID = data.Author.ID
@@ -211,7 +211,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler {
 			return nil
 		}
 
-		// 提取消息内容（去掉 @ 机器人部分）
+		// extract message content (remove @ bot part)
 		content := data.Content
 		if content == "" {
 			logger.DebugC("qq", "Received empty group message, ignoring")
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index 90c4297ca..7128980e4 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -252,7 +252,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) {
 		return
 	}
 
-	// 检查白名单，避免为被拒绝的用户下载附件
+	// check allowlist to avoid downloading attachments for rejected users
 	sender := bus.SenderInfo{
 		Platform:    "slack",
 		PlatformID:  ev.User,
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 6b5a84eda..005b311a2 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -299,7 +299,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
 		DisplayName: user.FirstName,
 	}
 
-	// 检查白名单，避免为被拒绝的用户下载附件
+	// check allowlist to avoid downloading attachments for rejected users
 	if !c.IsAllowedSender(sender) {
 		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]any{
 			"user_id": platformID,