fix(chat): render cards, forwards and encrypted messages

Normalize message projections across read shortcuts, preserve mixed user JSON, expand forwarded records, mask ciphertext, and accept media-download message ID aliases while retaining the Cobra/Schema required contract.

.gitignore

@@ -62,3 +62,7 @@ dwsbin
 /docs/shortcut-comparison.html
 /docs/shortcut-gsb-eval.*
 /scripts/run_shortcut_real_read_matrix.py
+
+# Local coverage artifacts
+coverage-shortcut.txt
+coverage-*.txt

CHANGELOG.md

@@ -6,6 +6,10 @@ The format is inspired by [Keep a Changelog](https://keepachangelog.com/) and th
 
 ## [Unreleased]
 
+### Fixed
+
+- **Message-read shortcut projection** (#706) — the message-list shortcuts (`chat +chat-messages` / `+messages-list` / `+messages-list-direct` / `+at-me` / `+search-msg` / `+thread-replies`) now render card and out-of-office rich-content JSON as readable text (without ever rewriting ordinary text that merely embeds a JSON fragment), expand a forwarded chat record's nested `forwardMessages` instead of collapsing to a "[卡片]" summary, and mark undecryptable encrypted card messages as `[加密消息]`; the speaker is read from the bare `sender` key, nested `{name:…}` sender objects yield their display name, and the literal string `"null"` is treated as absent. Shared projection helpers now live in `internal/shortcut/chatmsg`. `chat message download-media` also gains `--msg-id` / `--open-message-id` aliases for its `--message-id` flag so agents copying the `openMessageId`/`msgId` output field no longer hit "unknown flag".
+
 ## [1.0.54] - 2026-07-21
 
 This release promotes the validated `v1.0.54-beta.2` baseline to stable. It restores the default transport envelope for personal event output with opt-in flattening, plus Schema CLI path and plugin overlay compatibility fixes.

internal/helpers/chat.go

@@ -3143,6 +3143,25 @@ flow-status 取值：1=处理中(PROCESSING)，2=输入中(INPUTTING)，3=完成
   # resource-id: 从 dws chat message list 返回的消息内容中获取 mediaId
   # message-id: 从 dws chat message list 返回的 openMessageId
   # open-conversation-id: 从 dws chat search 获取 openConversationId`,
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			// Cobra validates required flags after PreRunE. Copy a supplied alias
+			// into the canonical flag first so --message-id can remain a hard
+			// required fact in both the executable and Agent Schema contracts.
+			if cmd.Flags().Changed("message-id") {
+				return nil
+			}
+			alias := ""
+			switch {
+			case cmd.Flags().Changed("msg-id"):
+				alias = "msg-id"
+			case cmd.Flags().Changed("open-message-id"):
+				alias = "open-message-id"
+			default:
+				return nil
+			}
+			value, _ := cmd.Flags().GetString(alias) // registered string flags above
+			return cmd.Flags().Set("message-id", value)
+		},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := validateRequiredFlags(cmd, "type", "resource-id", "message-id", "open-conversation-id", "output"); err != nil {
 				return err
@@ -3226,6 +3245,13 @@ flow-status 取值：1=处理中(PROCESSING)，2=输入中(INPUTTING)，3=完成
 	_ = chatMessageDownloadMediaCmd.MarkFlagRequired("open-conversation-id")
 	chatMessageDownloadMediaCmd.Flags().String("message-id", "", "消息 openMessageId (必填)")
 	_ = chatMessageDownloadMediaCmd.MarkFlagRequired("message-id")
+	// Hidden aliases: agents routinely pass --msg-id / --open-message-id since
+	// the message-list output exposes the field as openMessageId/msgId. Accept
+	// them transparently instead of failing with "unknown flag".
+	chatMessageDownloadMediaCmd.Flags().String("msg-id", "", "--message-id 的别名")
+	_ = chatMessageDownloadMediaCmd.Flags().MarkHidden("msg-id")
+	chatMessageDownloadMediaCmd.Flags().String("open-message-id", "", "--message-id 的别名")
+	_ = chatMessageDownloadMediaCmd.Flags().MarkHidden("open-message-id")
 	chatMessageDownloadMediaCmd.Flags().String("output", "", "本地保存路径，文件或目录 (必填)")
 	_ = chatMessageDownloadMediaCmd.MarkFlagRequired("output")
 

internal/helpers/chat_command_edges_test.go

@@ -222,6 +222,12 @@ func TestCrossPlatformCoverageChatWebhookReplyConversationAndDownloadEdges(t *te
 	tmp := t.TempDir()
 	base := []string{"message", "download-media", "--type=mediaId", "--resource-id=r", "--open-conversation-id=cid", "--message-id=mid"}
 	_ = runChatCoverageCommand(t, &productExampleCaller{dry: true}, append(base, "--output="+filepath.Join(tmp, "dry"))...)
+	for _, alias := range []string{"--msg-id=mid", "--open-message-id=mid"} {
+		aliasArgs := []string{"message", "download-media", "--type=mediaId", "--resource-id=r", "--open-conversation-id=cid", alias, "--output=" + filepath.Join(tmp, "alias-dry")}
+		_ = runChatCoverageCommand(t, &productExampleCaller{dry: true}, aliasArgs...)
+	}
+	missingMessageID := []string{"message", "download-media", "--type=mediaId", "--resource-id=r", "--open-conversation-id=cid", "--output=" + filepath.Join(tmp, "missing-id")}
+	_ = runChatCoverageCommand(t, &productExampleCaller{dry: true}, missingMessageID...)
 	for _, tc := range []struct {
 		step scriptedToolStep
 		out  string

internal/shortcut/chat/chat_message.go

@@ -17,6 +17,7 @@ import (
 	"fmt"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut"
+	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut/chatmsg"
 )
 
 // MessagesSend sends a text/markdown message as the current user
@@ -242,6 +243,11 @@ var MessagesList = shortcut.Shortcut{
 // clean output projection. Both the list container and the per-item field names are
 // probed defensively across candidate keys, so an empty or unexpected shape
 // yields an empty list rather than a crash or fabricated data.
+//
+// Text goes through the shared chatmsg projection so card/auto-reply JSON is
+// rendered readable and encrypted ciphertext is marked, and forwarded chat
+// records ("聊天记录") expand their nested messages under "forwarded" instead of
+// collapsing to a "[卡片]" summary.
 func listMessagesProject(data map[string]any) []map[string]any {
 	raw := listMessagesResolveList(data)
 	out := make([]map[string]any, 0, len(raw))
@@ -250,29 +256,39 @@ func listMessagesProject(data map[string]any) []map[string]any {
 		if !ok {
 			continue
 		}
-		row := map[string]any{}
-		if v, ok := listMessagesFirst(m, "openMessageId", "openMsgId", "messageId", "msgId"); ok {
-			row["messageId"] = v
-		}
-		if v, ok := listMessagesFirst(m, "senderOpenDingTalkId", "senderUserId", "senderId", "senderStaffId"); ok {
-			row["senderId"] = v
-		}
-		if v, ok := listMessagesFirst(m, "msgType", "messageType", "type"); ok {
-			row["msgType"] = v
-		}
-		if v, ok := listMessagesFirst(m, "createTime", "sendTime", "gmtCreate", "messageTime"); ok {
-			row["createTime"] = v
-		}
-		if v, ok := listMessagesFirst(m, "text", "content", "plainText"); ok {
-			row["text"] = v
-		}
-		if len(row) > 0 {
+		if row := listMessageProjectOne(m); len(row) > 0 {
 			out = append(out, row)
 		}
 	}
 	return out
 }
 
+// listMessageProjectOne projects a single message into the native
+// {messageId, senderId, msgType, createTime, text(, forwarded)} shape, reused
+// recursively for forwarded chat records.
+func listMessageProjectOne(m map[string]any) map[string]any {
+	row := map[string]any{}
+	if v, ok := listMessagesFirst(m, "openMessageId", "openMsgId", "messageId", "msgId"); ok {
+		row["messageId"] = v
+	}
+	if v, ok := listMessagesFirst(m, "senderOpenDingTalkId", "senderUserId", "senderId", "senderStaffId"); ok {
+		row["senderId"] = v
+	}
+	if v, ok := listMessagesFirst(m, "msgType", "messageType", "type"); ok {
+		row["msgType"] = v
+	}
+	if v, ok := listMessagesFirst(m, "createTime", "sendTime", "gmtCreate", "messageTime"); ok {
+		row["createTime"] = v
+	}
+	if text := chatmsg.Text(m); text != nil {
+		row["text"] = text
+	}
+	if forwarded := chatmsg.Forwarded(m, listMessageProjectOne); len(forwarded) > 0 {
+		row["forwarded"] = forwarded
+	}
+	return row
+}
+
 // listMessagesResolveList locates the list payload, tolerating a bare top-level
 // array container or nesting one level deeper under a common envelope key.
 func listMessagesResolveList(data map[string]any) []any {

internal/shortcut/chat/chat_message_project_test.go

@@ -0,0 +1,56 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chat
+
+import (
+	"strings"
+	"testing"
+)
+
+const testCipher = "SwzNkAraDE6lUHUNlVT3mjFdbxL6dWvmt77XtjACdpJx9VFibzTbW9KtDbkzGOYP||2||1||1"
+
+func TestListMessageProjectOne(t *testing.T) {
+	// full field mapping + forwarded expansion; an encrypted body is marked (no
+	// cross-conversation recovery), not leaked as base64.
+	row := listMessageProjectOne(map[string]any{
+		"openMessageId":        "mid",
+		"senderOpenDingTalkId": "DXYZ",
+		"msgType":              "text",
+		"createTime":           "2026-07-19 13:37:03",
+		"content":              testCipher,
+		"forwardMessages": []any{
+			map[string]any{"openMessageId": "c1", "senderOpenDingTalkId": "DA", "content": "子消息", "createTime": "t"},
+		},
+	})
+
+	if row["messageId"] != "mid" || row["senderId"] != "DXYZ" || row["msgType"] != "text" {
+		t.Fatalf("field mapping = %#v", row)
+	}
+	if row["createTime"] != "2026-07-19 13:37:03" {
+		t.Errorf("createTime = %v", row["createTime"])
+	}
+	if s, _ := row["text"].(string); !strings.Contains(s, "加密消息") || strings.Contains(s, "||2||1||") {
+		t.Errorf("encrypted text = %v, want marker", row["text"])
+	}
+	fwd, ok := row["forwarded"].([]map[string]any)
+	if !ok || len(fwd) != 1 || fwd[0]["messageId"] != "c1" || fwd[0]["text"] != "子消息" {
+		t.Errorf("forwarded = %#v", row["forwarded"])
+	}
+
+	// a bare message with no recognizable fields → empty row (no keys)
+	row = listMessageProjectOne(map[string]any{"unrelated": 1})
+	if len(row) != 0 {
+		t.Errorf("empty message row = %#v, want no keys", row)
+	}
+}

internal/shortcut/chatmsg/chatmsg.go

@@ -0,0 +1,292 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package chatmsg holds the shared, read-only projection helpers for DingTalk
+// message-list responses (list_individual_chat_message,
+// list_conversation_message_v2, search_at_me_message, search_messages_by_keyword,
+// list_topic_replies, …). Several shortcuts reshape those raw responses into a
+// clean speaker/text/time list; centralising the fiddly bits here keeps them
+// consistent and fixed in one place:
+//
+//   - Sender: the display name lives under the bare "sender" key, forwarded
+//     entries carry the literal string "null", and some responses nest the
+//     speaker in a {name:…} object — all handled here.
+//   - Text: out-of-office auto-replies / cards arrive as raw rich-content JSON,
+//     and card/robot messages arrive as undecryptable ciphertext; CleanText
+//     renders the former to readable text and marks the latter, WITHOUT ever
+//     rewriting ordinary text that merely contains a JSON fragment.
+//   - Forwarded: a forwarded chat record ("聊天记录") hides its real per-message
+//     bodies in forwardMessages while the top-level content is a lossy summary.
+package chatmsg
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+)
+
+// Sender reads a message's speaker display name, tolerating common sender-name
+// keys. The message-list responses carry the display name under the bare
+// "sender" key (verified live), so it is probed first; the remaining aliases and
+// the *Id fallbacks keep the projection resilient to other shapes. The literal
+// string "null" (forwarded entries) and the empty string are treated as absent,
+// and a nested {name:…} sender object yields its display name rather than the
+// raw object.
+func Sender(m map[string]any) any {
+	for _, key := range []string{"sender", "senderName", "senderNick", "nick", "senderStaffName", "userName", "name", "senderId", "senderStaffId", "senderOpenDingTalkId"} {
+		v, ok := m[key]
+		if !ok || v == nil {
+			continue
+		}
+		switch t := v.(type) {
+		case string:
+			if t == "" || t == "null" {
+				continue
+			}
+			return t
+		case map[string]any:
+			// Nested sender object: extract a display-name field; never return
+			// the raw map (it would surface a JSON object and block fallbacks).
+			if name := senderDisplayName(t); name != "" {
+				return name
+			}
+			continue
+		default:
+			// Scalar id (e.g. numeric) — usable as-is.
+			return v
+		}
+	}
+	return nil
+}
+
+// senderDisplayName extracts a human name from a nested sender object.
+func senderDisplayName(m map[string]any) string {
+	for _, k := range []string{"name", "nick", "userName", "staffName", "displayName", "senderName"} {
+		if s, ok := m[k].(string); ok {
+			if s = strings.TrimSpace(s); s != "" && s != "null" {
+				return s
+			}
+		}
+	}
+	return ""
+}
+
+// Text reads a message's textual content (tolerating common text keys and one
+// level of nesting) and runs it through CleanText.
+func Text(m map[string]any) any {
+	for _, key := range []string{"text", "content", "msgContent", "message", "body", "plainText"} {
+		v, ok := m[key]
+		if !ok || v == nil {
+			continue
+		}
+		switch t := v.(type) {
+		case string:
+			if t != "" {
+				return CleanText(t)
+			}
+		case map[string]any:
+			for _, inner := range []string{"text", "content", "value"} {
+				if s, ok := t[inner].(string); ok && s != "" {
+					return CleanText(s)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// CreateTime reads a message's create/send time under whichever candidate key is
+// present, returning the raw value.
+func CreateTime(m map[string]any) any {
+	for _, key := range []string{"createTime", "sendTime", "gmtCreate", "createAt", "timestamp", "time"} {
+		if v, ok := m[key]; ok && v != nil {
+			return v
+		}
+	}
+	return nil
+}
+
+// Forwarded projects the nested messages of a forwarded chat record. The caller
+// supplies its own per-message projection so each command keeps its own row
+// shape; project is applied recursively, so multi-level forwards expand too.
+func Forwarded(m map[string]any, project func(map[string]any) map[string]any) []map[string]any {
+	raw, ok := m["forwardMessages"].([]any)
+	if !ok || len(raw) == 0 {
+		return nil
+	}
+	out := make([]map[string]any, 0, len(raw))
+	for _, e := range raw {
+		if sub, ok := e.(map[string]any); ok {
+			out = append(out, project(sub))
+		}
+	}
+	return out
+}
+
+// CleanText makes a message body human-readable WITHOUT ever rewriting ordinary
+// text. It only transforms a body that is a genuine DingTalk structured message:
+//
+//   - Encrypted card/robot ciphertext (base64 + "||v||t||len" trailer) → a clear
+//     "[加密消息]" marker instead of the raw base64.
+//   - A rich-content card (out-of-office auto-reply, link/preview card, …) whose
+//     lines include at least one recognised rich-content block → the readable
+//     text extracted from those blocks, with the card's decorative JSON lines and
+//     "empty" placeholders dropped.
+//
+// Crucially, if NO line is a recognised rich-content block (e.g. ordinary text
+// that merely embeds a `{"approved":false}` fragment), the original string is
+// returned verbatim — a JSON line is never silently dropped.
+func CleanText(s string) string {
+	if IsEncrypted(s) {
+		return "[加密消息，无法解码]"
+	}
+
+	// Fast path: no JSON delimiters at all — the overwhelming common case.
+	if !strings.ContainsAny(s, "{[") {
+		return s
+	}
+
+	lines := strings.Split(s, "\n")
+	isJSON := make([]bool, len(lines))
+	isDecoration := make([]bool, len(lines))
+	extracted := make([][]string, len(lines))
+	anyExtracted := false
+	for i, line := range lines {
+		t := strings.TrimSpace(line)
+		if !strings.HasPrefix(t, "{") && !strings.HasPrefix(t, "[") {
+			continue
+		}
+		var v any
+		if json.Unmarshal([]byte(t), &v) != nil {
+			continue
+		}
+		isJSON[i] = true
+		isDecoration[i] = isKnownRichDecoration(v)
+		if texts := richItemTexts(v); len(texts) > 0 {
+			extracted[i] = texts
+			anyExtracted = true
+		}
+	}
+
+	// No recognised rich-content block anywhere → treat the whole body as plain
+	// text (which may merely contain a JSON fragment) and return it untouched.
+	if !anyExtracted {
+		return s
+	}
+
+	out := make([]string, 0, len(lines))
+	for i, line := range lines {
+		if len(extracted[i]) > 0 {
+			out = append(out, extracted[i]...)
+			continue
+		}
+		// In card mode, drop only JSON shapes known to be card decoration.
+		// Unrecognised JSON may be user-authored message content and must remain
+		// verbatim even when another line contains a rich-content block.
+		if isJSON[i] && isDecoration[i] {
+			continue
+		}
+		if t := strings.TrimSpace(line); t == "" || t == "empty" {
+			continue
+		}
+		out = append(out, line)
+	}
+	// anyExtracted is true here, so out always holds at least one non-empty
+	// extracted text — the joined result is never empty.
+	return strings.TrimSpace(strings.Join(out, "\n"))
+}
+
+// isKnownRichDecoration recognises the two decoration records emitted alongside
+// DingTalk rich-content bodies. Keep this deliberately narrow: an arbitrary JSON
+// object in the same message is user content unless its shape is known here.
+func isKnownRichDecoration(node any) bool {
+	m, ok := node.(map[string]any)
+	if !ok {
+		return false
+	}
+	_, hasPreviewURL := m["previewUrl"]
+	_, hasTitle := m["title"]
+	_, hasAutoLayout := m["autoLayout"]
+	_, hasEnableForward := m["enableForward"]
+	return (hasPreviewURL && hasTitle) || (hasAutoLayout && hasEnableForward)
+}
+
+// richItemTexts walks a decoded DingTalk rich-content blob and returns the
+// readable text carried by its rich-content items (items[].data.text). It only
+// harvests item bodies, so decorative fields (card titles, preview URLs, layout
+// config) contribute nothing and are dropped. An empty result means "not a
+// recognised rich-content block".
+func richItemTexts(node any) []string {
+	var texts []string
+	var walk func(n any)
+	walk = func(n any) {
+		switch t := n.(type) {
+		case []any:
+			for _, e := range t {
+				walk(e)
+			}
+		case map[string]any:
+			if items, ok := t["items"].([]any); ok {
+				for _, it := range items {
+					mm, ok := it.(map[string]any)
+					if !ok {
+						continue
+					}
+					data, ok := mm["data"].(map[string]any)
+					if !ok {
+						continue
+					}
+					if s, ok := data["text"].(string); ok {
+						if s = strings.TrimSpace(s); s != "" {
+							texts = append(texts, s)
+						}
+					}
+				}
+			}
+			for _, e := range t {
+				walk(e)
+			}
+		}
+	}
+	walk(node)
+	return texts
+}
+
+// encryptedTrailerRE matches DingTalk's encrypted-message trailer
+// "||<version>||<type>||<len>" (e.g. "||2||1||196") anchored at the end.
+var encryptedTrailerRE = regexp.MustCompile(`\|\|\d+\|\|\d+\|\|\d+\s*$`)
+
+// IsEncrypted reports whether a message body is a raw DingTalk encrypted-message
+// ciphertext: a base64 blob (DingTalk wraps it across several lines) followed by
+// the "||v||t||len" trailer. It is intentionally strict — both the trailer and a
+// pure-base64 body are required — so ordinary text (CJK, punctuation, …) never
+// trips it.
+func IsEncrypted(s string) bool {
+	s = strings.TrimSpace(s)
+	if !encryptedTrailerRE.MatchString(s) {
+		return false
+	}
+	body := strings.TrimSpace(encryptedTrailerRE.ReplaceAllString(s, ""))
+	if len(body) < 32 {
+		return false
+	}
+	for _, r := range body {
+		switch {
+		case r >= 'A' && r <= 'Z', r >= 'a' && r <= 'z', r >= '0' && r <= '9',
+			r == '+', r == '/', r == '=', r == '\n', r == '\r', r == ' ', r == '\t':
+		default:
+			return false
+		}
+	}
+	return true
+}

internal/shortcut/chatmsg/chatmsg_test.go

@@ -0,0 +1,176 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chatmsg
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSender(t *testing.T) {
+	// The display name lives under the bare "sender" key.
+	if got := Sender(map[string]any{"sender": "念晨", "senderOpenDingTalkId": "D1"}); got != "念晨" {
+		t.Fatalf("sender = %v, want 念晨", got)
+	}
+	// Falls back to the open id when no display name is present.
+	if got := Sender(map[string]any{"senderOpenDingTalkId": "DXYZ"}); got != "DXYZ" {
+		t.Fatalf("sender fallback = %v, want DXYZ", got)
+	}
+	// forwardMessages entries carry the literal string "null" — treat as absent.
+	if got := Sender(map[string]any{"sender": "null"}); got != nil {
+		t.Fatalf("sender \"null\" = %v, want nil", got)
+	}
+	if got := Sender(map[string]any{"sender": "null", "senderName": "念晨"}); got != "念晨" {
+		t.Fatalf("sender \"null\" fallthrough = %v, want 念晨", got)
+	}
+	// A nested {name:…} sender object yields its display name, not the raw map.
+	if got := Sender(map[string]any{"sender": map[string]any{"name": "Alice"}}); got != "Alice" {
+		t.Fatalf("nested sender = %v, want Alice", got)
+	}
+	// A nested sender object with no usable name must not block the fallback.
+	if got := Sender(map[string]any{"sender": map[string]any{"foo": "bar"}, "senderName": "Bob"}); got != "Bob" {
+		t.Fatalf("nested-no-name fallthrough = %v, want Bob", got)
+	}
+	// A scalar numeric id is returned as-is.
+	if got := Sender(map[string]any{"senderId": float64(42)}); got != float64(42) {
+		t.Fatalf("numeric sender id = %v", got)
+	}
+}
+
+func TestCleanText(t *testing.T) {
+	// Out-of-office auto-reply: readable body lives in items[].data.text; the
+	// decorative preview/config JSON lines and "empty" placeholder are dropped.
+	autoReply := "* 仅你和对方可见\n" +
+		`[{"text":{"minSupportVersion":"1.1","translateMap":{},"version":"1.2","items":[{"fallbackKey":"","data":{"text":"你好，我在出差中，消息回复可能不及时。"},"style":{"size":15,"bold":0},"type":"text"}]},"type":"markdown"}]` + "\n" +
+		`{"previewUrl":"dingtalk://x","title":{"text":"自动回复","type":"text"}}` + "\n" +
+		"empty\n" +
+		`{"autoLayout":false,"enableForward":false}`
+	if got, want := CleanText(autoReply), "* 仅你和对方可见\n你好，我在出差中，消息回复可能不及时。"; got != want {
+		t.Fatalf("auto-reply cleaned = %q, want %q", got, want)
+	}
+
+	// P1 regression: ordinary text whose middle line is a JSON fragment (no
+	// rich-content block anywhere) must be returned VERBATIM, not rewritten.
+	mixed := "payload:\n{\"approved\":false}\nplease check"
+	if got := CleanText(mixed); got != mixed {
+		t.Fatalf("mixed text was rewritten: got %q, want %q", got, mixed)
+	}
+
+	// An ordinary JSON line must also survive when a different line contains a
+	// recognised rich-content block. Card mode is not permission to discard
+	// unrelated user-authored JSON.
+	richAndPlain := `[{"items":[{"data":{"text":"卡片正文"}}]}]` + "\n" +
+		`{"approved":false}`
+	if got, want := CleanText(richAndPlain), "卡片正文\n{\"approved\":false}"; got != want {
+		t.Fatalf("mixed rich/plain JSON was rewritten: got %q, want %q", got, want)
+	}
+
+	// Malformed items (non-map item, item whose "data" isn't a map) are skipped;
+	// only the well-formed item's text is extracted.
+	blob := `[{"items":["notmap",{"data":"notmap"},{"data":{"text":"有效正文"}}]}]`
+	if got := CleanText(blob); got != "有效正文" {
+		t.Fatalf("CleanText rich edge = %q, want 有效正文", got)
+	}
+
+	tests := map[string]string{
+		"上周五 7.1 KW": "上周五 7.1 KW",
+		"上周客户统计的[图片消息](mediaId=@lQ)":                              "上周客户统计的[图片消息](mediaId=@lQ)",
+		"[文件] 简历.pdf fileId: qnY 注意：如需下载使用dws drive download命令下载": "[文件] 简历.pdf fileId: qnY 注意：如需下载使用dws drive download命令下载",
+		"[讨论] 排期\n明天开会":                                           "[讨论] 排期\n明天开会",
+		// a lone JSON object that isn't a rich-content block is left untouched
+		`{"autoLayout":false,"enableForward":false}`: `{"autoLayout":false,"enableForward":false}`,
+	}
+	for in, want := range tests {
+		if got := CleanText(in); got != want {
+			t.Errorf("CleanText(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestIsEncryptedAndMarker(t *testing.T) {
+	cipher := "SwzNkAraDE6lUHUNlVT3mjFdbxL6dWvmt77XtjACdpJx9VFibzTbW9KtDbkzGOYP\n" +
+		"7oDptklFO+YzDltH+myErV6rkc8URHYykpeSDsMP6kznFa9E320NsIntfY771dx+\n" +
+		"||2||1||196"
+	if !IsEncrypted(cipher) {
+		t.Fatalf("ciphertext not detected: %q", cipher)
+	}
+	if got := CleanText(cipher); !strings.Contains(got, "加密消息") || strings.Contains(got, "||2||1||") {
+		t.Fatalf("encrypted cleaned = %q, want marker not ciphertext", got)
+	}
+	for _, s := range []string{
+		"上周五 7.1 KW",
+		"价格 100||2||1||3",
+		"[图片消息](mediaId=@lQLPJwDw3VmNDcfMos0DhLB3OHPQeTBlzgov2Oi1ly4A)",
+		"大哥，我看了一下我觉得有几个点可以关注一下",
+		strings.Repeat("好", 20) + "||2||1||1", // long CJK body + trailer, not base64
+	} {
+		if IsEncrypted(s) {
+			t.Errorf("false positive: %q flagged as encrypted", s)
+		}
+	}
+}
+
+func TestText(t *testing.T) {
+	if got := Text(map[string]any{"content": "你好"}); got != "你好" {
+		t.Errorf("Text string = %v", got)
+	}
+	if got := Text(map[string]any{"content": map[string]any{"text": "嵌套"}}); got != "嵌套" {
+		t.Errorf("Text nested = %v", got)
+	}
+	if got := Text(map[string]any{"plainText": "纯文本"}); got != "纯文本" {
+		t.Errorf("Text plainText = %v", got)
+	}
+	if got := Text(map[string]any{"foo": 1}); got != nil {
+		t.Errorf("Text none = %v, want nil", got)
+	}
+}
+
+func TestCreateTime(t *testing.T) {
+	if got := CreateTime(map[string]any{"sendTime": "2026-07-19 13:37:03"}); got != "2026-07-19 13:37:03" {
+		t.Errorf("CreateTime = %v", got)
+	}
+	if got := CreateTime(map[string]any{}); got != nil {
+		t.Errorf("CreateTime empty = %v, want nil", got)
+	}
+}
+
+func TestForwarded(t *testing.T) {
+	var project func(m map[string]any) map[string]any
+	project = func(m map[string]any) map[string]any {
+		row := map[string]any{"text": Text(m)}
+		if fwd := Forwarded(m, project); len(fwd) > 0 { // recurse
+			row["forwarded"] = fwd
+		}
+		return row
+	}
+	if got := Forwarded(map[string]any{"content": "x"}, project); got != nil {
+		t.Errorf("Forwarded none = %v", got)
+	}
+	fwd := Forwarded(map[string]any{
+		"forwardMessages": []any{
+			map[string]any{"content": "a"},
+			"not-a-map",
+			map[string]any{"content": "b", "forwardMessages": []any{
+				map[string]any{"content": "nested"},
+			}},
+		},
+	}, project)
+	if len(fwd) != 2 || fwd[0]["text"] != "a" || fwd[1]["text"] != "b" {
+		t.Fatalf("Forwarded = %#v", fwd)
+	}
+	nested, ok := fwd[1]["forwarded"].([]map[string]any)
+	if !ok || len(nested) != 1 || nested[0]["text"] != "nested" {
+		t.Errorf("nested forwarded = %#v", fwd[1]["forwarded"])
+	}
+}

internal/shortcut/smart/at_me.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut"
+	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut/chatmsg"
 )
 
 // AtMe: pull the messages that recently @-mentioned ME across chats in one step.
@@ -91,12 +92,7 @@ var AtMe = shortcut.Shortcut{
 		}
 		results := make([]map[string]any, 0, len(items))
 		for _, m := range items {
-			results = append(results, map[string]any{
-				"sender":       atMeSender(m),
-				"time":         atMeTime(m),
-				"text":         atMeText(m),
-				"conversation": atMeConversation(m),
-			})
+			results = append(results, atMeProject(m))
 		}
 		return rt.Output(map[string]any{"messages": results})
 	},
@@ -194,28 +190,62 @@ func atMeToMaps(arr []any) []map[string]any {
 	return out
 }
 
+// atMeProject reshapes one @me message into {sender, time, text, conversation},
+// running text through the shared chatmsg cleaning (card/auto-reply JSON →
+// readable, ciphertext → marker) and recursively expanding any forwarded chat
+// record under "forwarded".
+func atMeProject(m map[string]any) map[string]any {
+	row := map[string]any{
+		"sender":       atMeSender(m),
+		"time":         atMeTime(m),
+		"text":         atMeCleanText(m),
+		"conversation": atMeConversation(m),
+	}
+	if forwarded := chatmsg.Forwarded(m, atMeProject); len(forwarded) > 0 {
+		row["forwarded"] = forwarded
+	}
+	return row
+}
+
+// atMeCleanText runs atMeText's extraction through chatmsg.CleanText so
+// card/auto-reply JSON and ciphertext render readable instead of leaking raw.
+func atMeCleanText(m map[string]any) any {
+	if s, ok := atMeText(m).(string); ok {
+		return chatmsg.CleanText(s)
+	}
+	return atMeText(m)
+}
+
 // atMeSender reads a message's sender display name/id, tolerating the common
-// sender keys the gateway may use (including a nested sender object).
+// sender keys the gateway may use (including a nested sender object). The literal
+// string "null" (carried by forwarded sub-messages) and the empty string are
+// both treated as absent so they never surface as the speaker.
 func atMeSender(m map[string]any) any {
+	norm := func(v any) string {
+		if s := atMeString(v); s != "" && s != "null" {
+			return s
+		}
+		return ""
+	}
 	for _, key := range []string{"senderName", "sender_name", "senderNick", "fromName", "senderStaffName"} {
-		if v := atMeString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}
 	for _, key := range []string{"sender", "from", "senderUser"} {
 		if nested, ok := m[key].(map[string]any); ok {
 			for _, k2 := range []string{"name", "nick", "userName", "staffName", "displayName"} {
-				if v := atMeString(nested[k2]); v != "" {
+				if v := norm(nested[k2]); v != "" {
 					return v
 				}
 			}
 		}
-		if v := atMeString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}
 	for _, key := range []string{"senderId", "sender_id", "senderUserId", "senderStaffId", "openDingTalkId"} {
-		if v := atMeString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}

internal/shortcut/smart/at_me_search_msg_test.go

@@ -0,0 +1,131 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package smart
+
+import (
+	"strings"
+	"testing"
+)
+
+const testCipher = "SwzNkAraDE6lUHUNlVT3mjFdbxL6dWvmt77XtjACdpJx9VFibzTbW9KtDbkzGOYP||2||1||1"
+
+func TestAtMeProject(t *testing.T) {
+	// nested sender object + plain text
+	row := atMeProject(map[string]any{
+		"sender":             map[string]any{"name": "念晨"},
+		"createTime":         "2026-07-19 13:37:03",
+		"content":            "普通消息",
+		"conversationTitle":  "群A",
+		"openConversationId": "cid1",
+	})
+	if row["sender"] != "念晨" || row["text"] != "普通消息" || row["conversation"] != "群A" {
+		t.Fatalf("atMeProject nested = %#v", row)
+	}
+
+	// encrypted content → marked (never leaked); id-only sender fallback; a
+	// forwarded sub-message whose sender is the literal "null" must be nulled.
+	row = atMeProject(map[string]any{
+		"senderId":      "DXYZ",
+		"openMessageId": "m1",
+		"content":       testCipher,
+		"forwardMessages": []any{
+			map[string]any{"sender": "null", "content": "子消息", "createTime": "t"},
+		},
+	})
+	if row["sender"] != "DXYZ" {
+		t.Errorf("atMeProject id-fallback sender = %v", row["sender"])
+	}
+	if s, _ := row["text"].(string); !strings.Contains(s, "加密消息") {
+		t.Errorf("atMeProject encrypted text = %v, want marker", row["text"])
+	}
+	fwd, ok := row["forwarded"].([]map[string]any)
+	if !ok || len(fwd) != 1 {
+		t.Fatalf("atMeProject forwarded = %#v", row["forwarded"])
+	}
+	if fwd[0]["sender"] != nil {
+		t.Errorf("forwarded sub sender = %v, want nil (literal \"null\")", fwd[0]["sender"])
+	}
+
+	// no sender / no text at all → nils, no forwarded key
+	row = atMeProject(map[string]any{"createTime": "t"})
+	if row["sender"] != nil || row["text"] != nil {
+		t.Errorf("atMeProject empty = %#v", row)
+	}
+	if _, has := row["forwarded"]; has {
+		t.Errorf("atMeProject plain unexpectedly has forwarded")
+	}
+}
+
+func TestSearchMsgProject(t *testing.T) {
+	// nested sender + plain text + messageId
+	row := searchMsgProject(map[string]any{
+		"sender":     map[string]any{"nick": "千启"},
+		"createTime": "2026-07-19 13:37:03",
+		"content":    "命中关键词的消息",
+		"msgId":      "mid1",
+	})
+	if row["sender"] != "千启" || row["text"] != "命中关键词的消息" {
+		t.Fatalf("searchMsgProject = %#v", row)
+	}
+
+	// encrypted → marker; id-only sender; forwarded "null" sender nulled.
+	row = searchMsgProject(map[string]any{
+		"senderId":      "DAAA",
+		"openMessageId": "m2",
+		"content":       testCipher,
+		"forwardMessages": []any{
+			map[string]any{"sender": "null", "content": "转发子消息", "createTime": "t"},
+		},
+	})
+	if row["sender"] != "DAAA" {
+		t.Errorf("searchMsgProject sender = %v", row["sender"])
+	}
+	if s, _ := row["text"].(string); !strings.Contains(s, "加密消息") {
+		t.Errorf("searchMsgProject encrypted text = %v, want marker", row["text"])
+	}
+	fwd, ok := row["forwarded"].([]map[string]any)
+	if !ok || len(fwd) != 1 || fwd[0]["sender"] != nil {
+		t.Errorf("searchMsgProject forwarded = %#v", row["forwarded"])
+	}
+
+	// no sender / no text
+	row = searchMsgProject(map[string]any{"createTime": "t"})
+	if row["sender"] != nil || row["text"] != nil {
+		t.Errorf("searchMsgProject empty = %#v", row)
+	}
+}
+
+// TestSenderHelpers exercises the atMe/searchMsg sender key families directly:
+// a senderName-family key (first probe loop), a flat string under "sender"
+// (second loop), and the "null" sentinel normalisation.
+func TestSenderHelpers(t *testing.T) {
+	cases := []struct {
+		fn   func(map[string]any) any
+		name string
+	}{
+		{atMeSender, "atMeSender"},
+		{searchMsgSender, "searchMsgSender"},
+	}
+	for _, c := range cases {
+		if got := c.fn(map[string]any{"senderName": "张三"}); got != "张三" {
+			t.Errorf("%s senderName = %v, want 张三", c.name, got)
+		}
+		if got := c.fn(map[string]any{"sender": "李四"}); got != "李四" {
+			t.Errorf("%s flat sender = %v, want 李四", c.name, got)
+		}
+		if got := c.fn(map[string]any{"senderName": "null"}); got != nil {
+			t.Errorf("%s \"null\" = %v, want nil", c.name, got)
+		}
+	}
+}

internal/shortcut/smart/chat_messages.go

@@ -17,6 +17,7 @@ import (
 	"strings"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut"
+	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut/chatmsg"
 )
 
 // ChatMessages: fetch the message list of one conversation (group OR single
@@ -111,11 +112,7 @@ var ChatMessages = shortcut.Shortcut{
 		items := chatMessageItems(data)
 		results := make([]map[string]any, 0, len(items))
 		for _, m := range items {
-			results = append(results, map[string]any{
-				"sender":     chatMessageSender(m),
-				"text":       chatMessageText(m),
-				"createTime": chatMessageCreateTime(m),
-			})
+			results = append(results, projectChatMessage(m))
 		}
 
 		return rt.Output(map[string]any{
@@ -156,53 +153,20 @@ func chatMessageItems(data map[string]any) []map[string]any {
 	return nil
 }
 
-// chatMessageSender reads a message's speaker display name, tolerating common
-// sender-name keys.
-func chatMessageSender(m map[string]any) any {
-	for _, key := range []string{"senderName", "senderNick", "nick", "senderStaffName", "userName", "name", "senderId", "senderStaffId"} {
-		if v, ok := m[key]; ok && v != nil {
-			if s, ok := v.(string); ok && s == "" {
-				continue
-			}
-			return v
-		}
+// projectChatMessage reshapes one raw message into the clean
+// {sender, text, createTime} projection, rendering card/auto-reply JSON and
+// marking encrypted messages via chatmsg, and recursively expanding forwarded
+// chat records under "forwarded".
+func projectChatMessage(m map[string]any) map[string]any {
+	row := map[string]any{
+		"sender":     chatmsg.Sender(m),
+		"text":       chatmsg.Text(m),
+		"createTime": chatmsg.CreateTime(m),
 	}
-	return nil
-}
-
-// chatMessageText reads a message's textual content, tolerating common text
-// keys and one level of nesting (e.g. {"content":{"text":"..."}}).
-func chatMessageText(m map[string]any) any {
-	for _, key := range []string{"text", "content", "msgContent", "message", "body"} {
-		v, ok := m[key]
-		if !ok || v == nil {
-			continue
-		}
-		switch t := v.(type) {
-		case string:
-			if t != "" {
-				return t
-			}
-		case map[string]any:
-			for _, inner := range []string{"text", "content", "value"} {
-				if s, ok := t[inner].(string); ok && s != "" {
-					return s
-				}
-			}
-		}
+	if forwarded := chatmsg.Forwarded(m, projectChatMessage); len(forwarded) > 0 {
+		row["forwarded"] = forwarded
 	}
-	return nil
-}
-
-// chatMessageCreateTime reads a message's create/send time, returning the raw
-// value under whichever candidate key is present.
-func chatMessageCreateTime(m map[string]any) any {
-	for _, key := range []string{"createTime", "sendTime", "gmtCreate", "createAt", "timestamp", "time"} {
-		if v, ok := m[key]; ok && v != nil {
-			return v
-		}
-	}
-	return nil
+	return row
 }
 
 func init() {

internal/shortcut/smart/chat_messages_test.go

@@ -0,0 +1,62 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package smart
+
+import "testing"
+
+// TestProjectChatMessageExpandsForwarded guards that a forwarded chat record
+// ("聊天记录") exposes its nested messages under "forwarded" instead of
+// collapsing to the lossy top-level "[卡片]" summary, recursing through nested
+// forwards, and that the string-"null" sender is nulled out. The per-field
+// behaviour (sender/text/encryption) is covered in the chatmsg package tests.
+func TestProjectChatMessageExpandsForwarded(t *testing.T) {
+	row := projectChatMessage(map[string]any{
+		"sender":     "hugozhu",
+		"content":    "hugozhu与opencode-agent的聊天记录\nopencode-agent:[卡片]",
+		"createTime": "2026-07-20 21:41:21",
+		"forwardMessages": []any{
+			map[string]any{"sender": "null", "content": "读下冬翔发给我的最近两条消息", "createTime": "2026-07-20 09:30:33"},
+			map[string]any{"sender": "冬翔", "content": "W29 工作总结", "createTime": "2026-07-19 23:35:40",
+				// nested forward inside a forward — must expand recursively.
+				"forwardMessages": []any{
+					map[string]any{"sender": "念晨", "content": "收到", "createTime": "2026-07-19 23:36:00"},
+				},
+			},
+		},
+	})
+
+	if row["sender"] != "hugozhu" {
+		t.Fatalf("top sender = %v, want hugozhu", row["sender"])
+	}
+	forwarded, ok := row["forwarded"].([]map[string]any)
+	if !ok || len(forwarded) != 2 {
+		t.Fatalf("forwarded = %#v, want 2 entries", row["forwarded"])
+	}
+	if forwarded[0]["sender"] != nil {
+		t.Errorf("forwarded[0].sender = %v, want nil (string \"null\")", forwarded[0]["sender"])
+	}
+	if forwarded[0]["text"] != "读下冬翔发给我的最近两条消息" {
+		t.Errorf("forwarded[0].text = %v", forwarded[0]["text"])
+	}
+	nested, ok := forwarded[1]["forwarded"].([]map[string]any)
+	if !ok || len(nested) != 1 || nested[0]["sender"] != "念晨" {
+		t.Errorf("nested forwarded = %#v, want 1 entry from 念晨", forwarded[1]["forwarded"])
+	}
+
+	// A plain message must not grow a "forwarded" key.
+	plain := projectChatMessage(map[string]any{"sender": "念晨", "content": "hi", "createTime": "t"})
+	if _, has := plain["forwarded"]; has {
+		t.Errorf("plain message unexpectedly has forwarded key: %#v", plain)
+	}
+}

internal/shortcut/smart/search_msg.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut"
+	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/shortcut/chatmsg"
 )
 
 // SearchMsg: search messages inside a single group chat by keyword in one step.
@@ -108,12 +109,7 @@ var SearchMsg = shortcut.Shortcut{
 		}
 		results := make([]map[string]any, 0, len(items))
 		for _, m := range items {
-			results = append(results, map[string]any{
-				"sender":    searchMsgSender(m),
-				"time":      searchMsgTime(m),
-				"text":      searchMsgText(m),
-				"messageId": searchMsgMessageID(m),
-			})
+			results = append(results, searchMsgProject(m))
 		}
 		return rt.Output(map[string]any{"messages": results})
 	},
@@ -152,28 +148,61 @@ func searchMsgToMaps(arr []any) []map[string]any {
 	return out
 }
 
+// searchMsgProject reshapes one matched message into {sender, time, text,
+// messageId}, running text through the shared chatmsg cleaning (card/auto-reply
+// JSON → readable, ciphertext → marker) and recursively expanding any forwarded
+// chat record under "forwarded".
+func searchMsgProject(m map[string]any) map[string]any {
+	row := map[string]any{
+		"sender":    searchMsgSender(m),
+		"time":      searchMsgTime(m),
+		"text":      searchMsgCleanText(m),
+		"messageId": searchMsgMessageID(m),
+	}
+	if forwarded := chatmsg.Forwarded(m, searchMsgProject); len(forwarded) > 0 {
+		row["forwarded"] = forwarded
+	}
+	return row
+}
+
+// searchMsgCleanText runs searchMsgText's extraction through chatmsg.CleanText.
+func searchMsgCleanText(m map[string]any) any {
+	if s, ok := searchMsgText(m).(string); ok {
+		return chatmsg.CleanText(s)
+	}
+	return searchMsgText(m)
+}
+
 // searchMsgSender reads a message's sender display name/id, tolerating the
-// common sender keys the gateway may use (including a nested sender object).
+// common sender keys the gateway may use (including a nested sender object). The
+// literal string "null" (carried by forwarded sub-messages) and the empty string
+// are both treated as absent so they never surface as the speaker.
 func searchMsgSender(m map[string]any) any {
+	norm := func(v any) string {
+		if s := searchMsgString(v); s != "" && s != "null" {
+			return s
+		}
+		return ""
+	}
 	for _, key := range []string{"senderName", "sender_name", "senderNick", "fromName", "senderStaffName"} {
-		if v := searchMsgString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}
 	for _, key := range []string{"sender", "from", "senderUser"} {
 		if nested, ok := m[key].(map[string]any); ok {
 			for _, k2 := range []string{"name", "nick", "userName", "staffName", "displayName"} {
-				if v := searchMsgString(nested[k2]); v != "" {
+				if v := norm(nested[k2]); v != "" {
 					return v
 				}
 			}
 		}
-		if v := searchMsgString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}
 	for _, key := range []string{"senderId", "sender_id", "senderUserId", "senderStaffId", "openDingTalkId"} {
-		if v := searchMsgString(m[key]); v != "" {
+		if v := norm(m[key]); v != "" {
 			return v
 		}
 	}

internal/shortcut/smart/thread_replies.go

@@ -78,11 +78,7 @@ var ThreadReplies = shortcut.Shortcut{
 		items := threadReplyItems(data)
 		results := make([]map[string]any, 0, len(items))
 		for _, m := range items {
-			results = append(results, map[string]any{
-				"sender":     threadReplySender(m),
-				"text":       threadReplyText(m),
-				"createTime": threadReplyCreateTime(m),
-			})
+			results = append(results, projectChatMessage(m))
 		}
 
 		return rt.Output(map[string]any{
@@ -124,55 +120,6 @@ func threadReplyItems(data map[string]any) []map[string]any {
 	return nil
 }
 
-// threadReplySender reads a reply's speaker display name, tolerating common
-// sender-name keys.
-func threadReplySender(m map[string]any) any {
-	for _, key := range []string{"senderName", "senderNick", "nick", "senderStaffName", "userName", "name", "senderId", "senderStaffId"} {
-		if v, ok := m[key]; ok && v != nil {
-			if s, ok := v.(string); ok && s == "" {
-				continue
-			}
-			return v
-		}
-	}
-	return nil
-}
-
-// threadReplyText reads a reply's textual content, tolerating common text keys
-// and one level of nesting (e.g. {"text":{"content":"..."}}).
-func threadReplyText(m map[string]any) any {
-	for _, key := range []string{"text", "content", "msgContent", "message", "body"} {
-		v, ok := m[key]
-		if !ok || v == nil {
-			continue
-		}
-		switch t := v.(type) {
-		case string:
-			if t != "" {
-				return t
-			}
-		case map[string]any:
-			for _, inner := range []string{"content", "text", "value"} {
-				if s, ok := t[inner].(string); ok && s != "" {
-					return s
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// threadReplyCreateTime reads a reply's create/send time, returning the raw
-// value under whichever candidate key is present.
-func threadReplyCreateTime(m map[string]any) any {
-	for _, key := range []string{"createTime", "sendTime", "gmtCreate", "createAt", "timestamp", "time"} {
-		if v, ok := m[key]; ok && v != nil {
-			return v
-		}
-	}
-	return nil
-}
-
 func init() {
 	shortcut.Register(ThreadReplies)
 }