Recover visible sidechain summaries

Author: SqlRush

docs/claude-code-go-rewrite-plan.md

@@ -220,6 +220,7 @@ test/parity/                 # golden tests against TS/official behavior
 - 本轮补充：remote history pagination 现在接受 `starting_after`/`startingAfter`/`after*` cursor aliases，page 字段和 link URL query 都可驱动下一页 `before_id` 续抓。
 - 本轮补充：remote history `SDKEvent` 本体接受 `eventType`/`event_type`/`role` 类型别名、`createdAt`/`created_at` 时间戳别名，以及 `payload`/`data`/`body`/`metadata`/`meta`/`attributes`/`properties`/`serializedMessage` message payload 别名；payload 只有 `role`/`content` 时也能 materialize 成 transcript message。
 - 本轮补充：sidechain lifecycle 读取现在接受运行时相邻字段别名，包括 `jobId`/`threadId`/`workflowId`/`operationId`/`requestId`、`workerType`/`taskType`、`workspaceRoot`/`projectPath`、`instructions`/`operationName`/`commandName`/`displayTitle`、`jobStatus`、`resultState`、`outputText` 和毫秒级 start/end time 字段，并会递归解包 `runtime`/`context`/`state` 容器。
+- 本轮补充：sidechain lifecycle 和 metadata sidecar 的 task description/summary 读取现在接受 visible text payload，包括 text content block、message object、content block array、provider-style `message.content`/`parts`/`outputText` wrapper，并继续跳过 thinking/tool/image 等非可见块。
 - 本轮补充：transcript resume 的嵌套 content block 接受 `toolUseId`/`toolUseID`、`isError`、`cacheControl`、`cacheReference` 字段别名，并保留 cache edit 的 `cacheReference`。
 - 本轮补充：transcript resume 的 nested content block `id`/`tool_use_id`/`toolUseId` 现在接受 JSON number，并保留为字符串 tool-use ID。
 - 本轮补充：嵌套 contract message 的 `content` 接受字符串、单个 content-block 对象，以及混合字符串/content-block 数组；字符串会归一为 text block，并接受 `text`/`body`/`message`/`value`/`output` 正文字段和 `role`/`messageType` 类型别名，提升 transcript/remote history payload 恢复率。

docs/first-second-parity-audit.md

@@ -207,6 +207,7 @@ M6 progress now includes:
 - `internal/session`: sidechain lifecycle field extraction now also traverses collection wrappers such as `edges`, `nodes`, and `included`, plus array elements, so GraphQL connection or JSON:API included start/summary payloads can still recover state/list/resume fields.
 - `internal/session`: sidechain lifecycle scalar fields now accept JSON number values for IDs and other string-like fields, preserving numeric subagent IDs as strings across state/list/resume recovery.
 - `internal/session`: sidechain lifecycle and metadata sidecar loading now accept adjacent runtime aliases such as `jobId`, `threadId`, `workflowId`, `operationId`, `requestId`, `workerType`, `taskType`, `workspaceRoot`, `projectPath`, `instructions`, `operationName`, `commandName`, `displayTitle`, `jobStatus`, `resultState`, `outputText`, and millisecond start/end time fields under `runtime`/`context`/`state` or JSON:API/resource wrappers.
+- `internal/session`: sidechain lifecycle and metadata sidecar summary/description loading now accepts visible text payloads, including text content blocks, message objects, content block arrays, and provider-style `message.content`/`parts`/`outputText` wrappers while ignoring hidden thinking/tool/image blocks.
 - `internal/session`: sidechain runtime finish now canonicalizes status aliases such as `success`, `error`, and `canceled` before writing summary records, keeping sidechain and main transcript lifecycle output stable.
 - `internal/session`: sidechain runtime now rejects duplicate starts while the same sidechain ID is running, and state loading treats a later start as a fresh lifecycle by clearing stale summary/end metadata.
 - `internal/session`: sidechain lifecycle state loading now accepts adjacent subtype aliases such as `subagent_started`, `agentStarted`, `task_failed`, and `sidechainCompleted`, with broader task/worker/run ID fields plus `resultText`/`finalMessage` summaries and subtype-derived failed/cancelled defaults.

internal/session/sidechain_metadata.go

@@ -26,7 +26,7 @@ func (m *SidechainMetadata) UnmarshalJSON(data []byte) error {
 		metadata.AgentType = topLevelStringField(fields, "type")
 	}
 	metadata.WorktreePath = firstStringField(fields, sidechainLifecycleWorktreeFields...)
-	metadata.Description = firstStringField(fields, sidechainLifecycleDescriptionFields...)
+	metadata.Description = firstTextField(fields, sidechainLifecycleDescriptionFields...)
 	*m = metadata
 	return nil
 }

internal/session/sidechain_status.go

@@ -10,6 +10,7 @@ import (
 	"unicode"
 
 	"ccgo/internal/contracts"
+	msgs "ccgo/internal/messages"
 )
 
 type SidechainState struct {
@@ -198,7 +199,7 @@ func LoadSidechainState(info SidechainInfo) (SidechainState, error) {
 			if worktreePath := firstStringField(msg.Content, sidechainLifecycleWorktreeFields...); worktreePath != "" && state.Metadata.WorktreePath == "" {
 				state.Metadata.WorktreePath = worktreePath
 			}
-			if description := firstStringField(msg.Content, sidechainLifecycleDescriptionFields...); description != "" && state.Metadata.Description == "" {
+			if description := firstTextField(msg.Content, sidechainLifecycleDescriptionFields...); description != "" && state.Metadata.Description == "" {
 				state.Metadata.Description = description
 			}
 			if status := sidechainStatusField(msg.Content, sidechainLifecycleStartStatusFields...); status != "" {
@@ -220,7 +221,7 @@ func LoadSidechainState(info SidechainInfo) (SidechainState, error) {
 			} else {
 				state.Status = SidechainStatusCompleted
 			}
-			state.Summary = firstStringField(msg.Content, sidechainLifecycleSummaryFields...)
+			state.Summary = firstTextField(msg.Content, sidechainLifecycleSummaryFields...)
 		}
 	}
 	if state.Status == SidechainStatusUnknown {
@@ -411,6 +412,10 @@ func firstStringField(value any, keys ...string) string {
 	return firstStringFieldDepth(value, keys, 0)
 }
 
+func firstTextField(value any, keys ...string) string {
+	return firstTextFieldDepth(value, keys, 0)
+}
+
 func firstStringFieldDepth(value any, keys []string, depth int) string {
 	if depth > 4 {
 		return ""
@@ -448,6 +453,137 @@ func firstStringFieldDepth(value any, keys []string, depth int) string {
 	return ""
 }
 
+func firstTextFieldDepth(value any, keys []string, depth int) string {
+	if depth > 4 {
+		return ""
+	}
+	switch fields := value.(type) {
+	case map[string]any:
+		for _, key := range keys {
+			if raw, ok := fields[key]; ok {
+				if value := visibleTextField(raw); value != "" {
+					return value
+				}
+			}
+		}
+		for _, key := range []string{"payload", "data", "body", "content", "result", "response", "record", "records", "entry", "entries", "item", "items", "event", "events", "edge", "edges", "node", "nodes", "resource", "resources", "attributes", "properties", "attrs", "metadata", "details", "runtime", "context", "state", "value", "values", "output", "outputs", "included", "collection", "list", "children"} {
+			if raw, ok := fields[key]; ok {
+				if value := firstTextFieldDepth(raw, keys, depth+1); value != "" {
+					return value
+				}
+			}
+		}
+	case []any:
+		for _, item := range fields {
+			if value := firstTextFieldDepth(item, keys, depth+1); value != "" {
+				return value
+			}
+		}
+	case map[string]string:
+		for _, key := range keys {
+			if raw := fields[key]; raw != "" {
+				return raw
+			}
+		}
+	default:
+	}
+	return ""
+}
+
+func visibleTextField(value any) string {
+	if value == nil {
+		return ""
+	}
+	if value := scalarStringField(value); value != "" {
+		return value
+	}
+	if text := visibleContentBlockText(value); text != "" {
+		return text
+	}
+	if nonVisibleContentBlock(value) {
+		return ""
+	}
+	if text := visibleMessageText(value); text != "" {
+		return text
+	}
+	switch raw := value.(type) {
+	case map[string]any:
+		for _, key := range []string{
+			"summary", "summaryText", "summary_text", "finalSummary", "final_summary",
+			"resultSummary", "result_summary", "resultText", "result_text",
+			"finalMessage", "final_message", "completion", "completionText", "completion_text",
+			"outputText", "output_text", "messageText", "message_text",
+			"body", "text", "message", "content", "parts", "segments", "output", "value",
+			"detail", "details", "description",
+		} {
+			if nested, ok := raw[key]; ok {
+				if text := visibleTextField(nested); text != "" {
+					return text
+				}
+			}
+		}
+	case []any:
+		parts := make([]string, 0, len(raw))
+		for _, item := range raw {
+			if text := visibleTextField(item); text != "" {
+				parts = append(parts, text)
+			}
+		}
+		return strings.Join(parts, "\n")
+	case map[string]string:
+		for _, key := range []string{"text", "body", "message", "content", "value", "output", "summary", "description", "details"} {
+			if text := raw[key]; text != "" {
+				return text
+			}
+		}
+	}
+	return ""
+}
+
+func visibleContentBlockText(value any) string {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return ""
+	}
+	var block contracts.ContentBlock
+	if err := json.Unmarshal(data, &block); err != nil {
+		return ""
+	}
+	if block.Type == contracts.ContentText && block.Text != "" {
+		return block.Text
+	}
+	return ""
+}
+
+func nonVisibleContentBlock(value any) bool {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return false
+	}
+	var block contracts.ContentBlock
+	if err := json.Unmarshal(data, &block); err != nil {
+		return false
+	}
+	switch block.Type {
+	case contracts.ContentThinking, contracts.ContentToolUse, contracts.ContentToolResult, contracts.ContentImage, contracts.ContentCacheEdits:
+		return true
+	default:
+		return false
+	}
+}
+
+func visibleMessageText(value any) string {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return ""
+	}
+	var message contracts.Message
+	if err := json.Unmarshal(data, &message); err != nil {
+		return ""
+	}
+	return msgs.TextContent(message)
+}
+
 func scalarStringField(value any) string {
 	switch raw := value.(type) {
 	case string:

internal/session/sidechain_test.go

@@ -493,6 +493,63 @@ func TestLoadSidechainStateAcceptsWrappedLifecycleContent(t *testing.T) {
 	}
 }
 
+func TestLoadSidechainStateAcceptsVisibleTextLifecyclePayloads(t *testing.T) {
+	sessionPath := filepath.Join(t.TempDir(), "session.jsonl")
+	sessionID := contracts.ID("sess_1")
+	if err := AppendSidechainMessage(sessionPath, sessionID, "text-payload", TranscriptMessage{
+		Type:      "system",
+		UUID:      "start_1",
+		Timestamp: "2026-01-01T00:00:01Z",
+		Subtype:   "subagent_started",
+		Content: map[string]any{
+			"payload": map[string]any{
+				"subagentId":    "text_worker",
+				"agentName":     "writer",
+				"workspacePath": "/tmp/text-worktree",
+				"taskDescription": map[string]any{
+					"type": "text",
+					"text": "write visible payload support",
+				},
+				"status": "running",
+			},
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if err := AppendSidechainMessage(sessionPath, sessionID, "text-payload", TranscriptMessage{
+		Type:      "system",
+		UUID:      "summary_1",
+		Timestamp: "2026-01-01T00:00:02Z",
+		Subtype:   "agent_finish",
+		Content: map[string]any{
+			"response": map[string]any{
+				"agentID": "text_worker",
+				"outcome": "completedSuccessfully",
+				"message": map[string]any{
+					"role": "assistant",
+					"content": []any{
+						map[string]any{"type": "text", "text": "visible provider summary"},
+						map[string]any{"type": "thinking", "text": "hidden chain of thought"},
+					},
+				},
+			},
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	state, err := FindSidechainState(sessionPath, sessionID, "text-payload")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if state.ID != "text_worker" || state.Status != SidechainStatusCompleted || state.Summary != "visible provider summary" {
+		t.Fatalf("state = %#v", state)
+	}
+	if state.Metadata.AgentType != "writer" || state.Metadata.WorktreePath != "/tmp/text-worktree" || state.Metadata.Description != "write visible payload support" {
+		t.Fatalf("metadata = %#v", state.Metadata)
+	}
+}
+
 func TestLoadSidechainStateAcceptsResourceLifecycleAttributes(t *testing.T) {
 	sessionPath := filepath.Join(t.TempDir(), "session.jsonl")
 	sessionID := contracts.ID("sess_1")
@@ -833,6 +890,45 @@ func TestLoadSidechainStateAcceptsWrappedMetadataSidecarAliases(t *testing.T) {
 	}
 }
 
+func TestLoadSidechainStateAcceptsVisibleTextMetadataSidecarAliases(t *testing.T) {
+	sessionPath := filepath.Join(t.TempDir(), "session.jsonl")
+	sessionID := contracts.ID("sess_1")
+	if err := AppendSidechainMessage(sessionPath, sessionID, "text_meta", TranscriptMessage{
+		Type: "assistant",
+		UUID: "msg_1",
+	}); err != nil {
+		t.Fatal(err)
+	}
+	metadataPath := SidechainMetadataPath(sessionPath, sessionID, "text_meta")
+	if err := os.WriteFile(metadataPath, []byte(`{
+		"resource": {
+			"id": "meta_2",
+			"type": "sidechain-metadata",
+			"attributes": {
+				"agentName": "summarizer",
+				"workspaceRoot": "/tmp/summary-worktree",
+				"description": {
+					"role": "assistant",
+					"content": [
+						{"type": "text", "text": "summarize wrapped text metadata"},
+						{"type": "thinking", "text": "hidden"}
+					]
+				}
+			}
+		}
+	}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	state, err := FindSidechainState(sessionPath, sessionID, "text_meta")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if state.Metadata.AgentType != "summarizer" || state.Metadata.WorktreePath != "/tmp/summary-worktree" || state.Metadata.Description != "summarize wrapped text metadata" {
+		t.Fatalf("metadata = %#v", state.Metadata)
+	}
+}
+
 func TestSidechainManagerOrchestratesRunningSidechains(t *testing.T) {
 	sessionPath := filepath.Join(t.TempDir(), "session.jsonl")
 	sessionID := contracts.ID("sess_1")