fix: capture plan content from Read tool results + use HEAD commit message for orphan branch

Plan files read via the Read tool were not being captured. Track Read
tool_use IDs targeting .claude/plans/ files and extract the plan text
from the corresponding tool_result in the next user message.

Also use the main branch HEAD commit message for orphan branch commits
instead of the hardcoded "rekal: checkpoint".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Frank Guo

cmd/rekal/cli/export.go

@@ -255,8 +255,16 @@ func commitWireFormat(gitRoot string, bodyData, dictData []byte) (string, error)
 	}
 	treeHash := strings.TrimSpace(string(treeOut))
 
+	// Use the HEAD commit message from the main branch.
+	msg := "rekal: checkpoint"
+	if headMsg, err := exec.Command("git", "-C", gitRoot, "log", "-1", "--format=%s", "HEAD").Output(); err == nil {
+		if m := strings.TrimSpace(string(headMsg)); m != "" {
+			msg = m
+		}
+	}
+
 	commitOut, err := exec.Command("git", "-C", gitRoot,
-		"commit-tree", treeHash, "-p", parent, "-m", "rekal: checkpoint",
+		"commit-tree", treeHash, "-p", parent, "-m", msg,
 	).Output()
 	if err != nil {
 		return "", fmt.Errorf("commit-tree: %w", err)

cmd/rekal/cli/session/parse.go

@@ -55,11 +55,15 @@ type rawMessage struct {
 }
 
 // contentBlock represents a single block in an assistant message's content array.
+// Also used for tool_result blocks in user messages.
 type contentBlock struct {
-	Type  string          `json:"type"`
-	Text  string          `json:"text"`
-	Name  string          `json:"name"`
-	Input json.RawMessage `json:"input"`
+	Type      string          `json:"type"`
+	Text      string          `json:"text"`
+	Name      string          `json:"name"`
+	ID        string          `json:"id"`          // tool_use block ID
+	ToolUseID string          `json:"tool_use_id"` // tool_result reference
+	Input     json.RawMessage `json:"input"`
+	Content   json.RawMessage `json:"content"` // tool_result content (string or array)
 }
 
 // toolInput holds common fields from tool_use input blocks.
@@ -78,6 +82,10 @@ func ParseTranscript(data []byte) (*SessionPayload, error) {
 		ActorType: "human",
 	}
 
+	// pendingPlanReads tracks tool_use IDs for Read calls targeting .claude/plans/ files.
+	// When the corresponding tool_result arrives in a user message, we extract the plan text.
+	pendingPlanReads := make(map[string]bool)
+
 	scanner := bufio.NewScanner(bytes.NewReader(data))
 	// Increase scanner buffer for large lines (tool results can be huge).
 	scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024)
@@ -114,21 +122,22 @@ func ParseTranscript(data []byte) (*SessionPayload, error) {
 
 		switch raw.Type {
 		case "user":
-			turn, err := parseUserTurn(raw.Message, ts)
+			turns, err := parseUserTurn(raw.Message, ts, pendingPlanReads)
 			if err != nil {
 				continue
 			}
-			if turn != nil {
-				payload.Turns = append(payload.Turns, *turn)
-			}
+			payload.Turns = append(payload.Turns, turns...)
 
 		case "assistant":
-			turns, toolCalls, err := parseAssistantMessage(raw.Message, ts)
+			turns, toolCalls, planReadIDs, err := parseAssistantMessage(raw.Message, ts)
 			if err != nil {
 				continue
 			}
 			payload.Turns = append(payload.Turns, turns...)
 			payload.ToolCalls = append(payload.ToolCalls, toolCalls...)
+			for _, id := range planReadIDs {
+				pendingPlanReads[id] = true
+			}
 		}
 	}
 
@@ -141,8 +150,10 @@ func ParseTranscript(data []byte) (*SessionPayload, error) {
 }
 
 // parseUserTurn extracts the text content from a user message.
-// It skips tool_result blocks (which contain file bodies, command outputs).
-func parseUserTurn(msgRaw json.RawMessage, ts time.Time) (*Turn, error) {
+// It skips tool_result blocks (which contain file bodies, command outputs),
+// except for tool_results matching pendingPlanReads — those contain plan file
+// content that should be indexed.
+func parseUserTurn(msgRaw json.RawMessage, ts time.Time, pendingPlanReads map[string]bool) ([]Turn, error) {
 	if len(msgRaw) == 0 {
 		return nil, nil
 	}
@@ -156,37 +167,48 @@ func parseUserTurn(msgRaw json.RawMessage, ts time.Time) (*Turn, error) {
 		return nil, nil
 	}
 
+	var turns []Turn
+
+	// Extract plan content from tool_result blocks matching pending plan reads.
+	if len(pendingPlanReads) > 0 {
+		planTurns := extractPlanToolResults(msg.Content, ts, pendingPlanReads)
+		turns = append(turns, planTurns...)
+	}
+
 	text := extractTextContent(msg.Content)
-	if text == "" {
-		return nil, nil
+	if text != "" {
+		turns = append(turns, Turn{
+			Role:      "human",
+			Content:   text,
+			Timestamp: ts,
+		})
 	}
 
-	return &Turn{
-		Role:      "human",
-		Content:   text,
-		Timestamp: ts,
-	}, nil
+	return turns, nil
 }
 
 // parseAssistantMessage extracts text turns and tool calls from an assistant message.
 // It discards thinking blocks and tool results.
-func parseAssistantMessage(msgRaw json.RawMessage, ts time.Time) ([]Turn, []ToolCall, error) {
+// It also returns IDs of Read tool_use blocks targeting .claude/plans/ files,
+// so the caller can match them against subsequent tool_result blocks.
+func parseAssistantMessage(msgRaw json.RawMessage, ts time.Time) ([]Turn, []ToolCall, []string, error) {
 	if len(msgRaw) == 0 {
-		return nil, nil, nil
+		return nil, nil, nil, nil
 	}
 
 	var msg rawMessage
 	if err := json.Unmarshal(msgRaw, &msg); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	if msg.Role != "assistant" {
-		return nil, nil, nil
+		return nil, nil, nil, nil
 	}
 
 	// Content can be a string or an array of blocks.
 	var turns []Turn
 	var toolCalls []ToolCall
+	var planReadIDs []string
 
 	// Try as string first.
 	var textContent string
@@ -198,13 +220,13 @@ func parseAssistantMessage(msgRaw json.RawMessage, ts time.Time) ([]Turn, []Tool
 				Timestamp: ts,
 			})
 		}
-		return turns, nil, nil
+		return turns, nil, nil, nil
 	}
 
 	// Parse as array of content blocks.
 	var blocks []contentBlock
 	if err := json.Unmarshal(msg.Content, &blocks); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	var textParts []string
@@ -225,6 +247,10 @@ func parseAssistantMessage(msgRaw json.RawMessage, ts time.Time) ([]Turn, []Tool
 					Timestamp: ts,
 				})
 			}
+			// Track Read calls targeting plan files.
+			if id := extractPlanReadID(b); id != "" {
+				planReadIDs = append(planReadIDs, id)
+			}
 			// Discard: "thinking", "tool_result", etc.
 		}
 	}
@@ -244,7 +270,7 @@ func parseAssistantMessage(msgRaw json.RawMessage, ts time.Time) ([]Turn, []Tool
 		})
 	}
 
-	return turns, toolCalls, nil
+	return turns, toolCalls, planReadIDs, nil
 }
 
 // extractTextContent pulls text from a message content field.
@@ -341,6 +367,105 @@ func extractPlanContent(b contentBlock) string {
 	return inp.Content
 }
 
+// extractPlanReadID returns the tool_use ID if this is a Read tool call
+// targeting a .claude/plans/ file. The caller uses this to match the
+// corresponding tool_result in the next user message.
+func extractPlanReadID(b contentBlock) string {
+	if b.Name != "Read" {
+		return ""
+	}
+	if len(b.Input) == 0 || b.ID == "" {
+		return ""
+	}
+
+	var inp toolInput
+	if err := json.Unmarshal(b.Input, &inp); err != nil {
+		return ""
+	}
+
+	path := inp.FilePath
+	if path == "" {
+		path = inp.Path
+	}
+	if !strings.Contains(path, ".claude/plans/") {
+		return ""
+	}
+
+	return b.ID
+}
+
+// extractPlanToolResults scans user message content blocks for tool_result
+// blocks whose tool_use_id matches a pending plan read. For each match, it
+// extracts the text and emits it as an assistant turn (the content originated
+// from the assistant's Read call). Matched IDs are removed from the map.
+func extractPlanToolResults(content json.RawMessage, ts time.Time, pending map[string]bool) []Turn {
+	if len(content) == 0 {
+		return nil
+	}
+
+	var blocks []contentBlock
+	if err := json.Unmarshal(content, &blocks); err != nil {
+		return nil
+	}
+
+	var turns []Turn
+	for _, b := range blocks {
+		if b.Type != "tool_result" {
+			continue
+		}
+		if !pending[b.ToolUseID] {
+			continue
+		}
+
+		text := extractToolResultText(b.Content)
+		if text != "" {
+			turns = append(turns, Turn{
+				Role:      "assistant",
+				Content:   text,
+				Timestamp: ts,
+			})
+		}
+		delete(pending, b.ToolUseID)
+	}
+	return turns
+}
+
+// extractToolResultText extracts text from a tool_result content field,
+// which can be a plain string or an array of content blocks.
+func extractToolResultText(content json.RawMessage) string {
+	if len(content) == 0 {
+		return ""
+	}
+
+	// Try string.
+	var s string
+	if err := json.Unmarshal(content, &s); err == nil {
+		return s
+	}
+
+	// Try array of blocks.
+	var blocks []contentBlock
+	if err := json.Unmarshal(content, &blocks); err != nil {
+		return ""
+	}
+
+	var parts []string
+	for _, b := range blocks {
+		if b.Type == "text" && b.Text != "" {
+			parts = append(parts, b.Text)
+		}
+	}
+
+	combined := ""
+	for i, p := range parts {
+		if i > 0 {
+			combined += "\n"
+		}
+		combined += p
+	}
+	return combined
+}
+
 func truncate(s string, maxLen int) string {
 	if len(s) <= maxLen {
 		return s

cmd/rekal/cli/session/parse_test.go

@@ -175,6 +175,66 @@ func TestParseTranscript_PlanContentCaptured(t *testing.T) {
 	}
 }
 
+func TestParseTranscript_PlanReadCaptured(t *testing.T) {
+	t.Parallel()
+
+	// Simulate: assistant reads a plan file, then user message contains the tool_result with plan content.
+	input := `{"uuid":"pr1","sessionId":"s5","timestamp":"2025-01-15T10:00:00Z","type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Let me read the plan."},{"type":"tool_use","id":"tu-read-plan","name":"Read","input":{"file_path":"/home/user/.claude/plans/my-plan.md"}}]},"gitBranch":"main"}
+{"uuid":"pr2","sessionId":"s5","timestamp":"2025-01-15T10:00:01Z","type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu-read-plan","content":"# Plan\n\n## Step 1\nDo the thing.\n\n## Step 2\nDo the other thing."}]},"gitBranch":"main"}`
+
+	payload, err := ParseTranscript([]byte(input))
+	if err != nil {
+		t.Fatalf("ParseTranscript: %v", err)
+	}
+
+	// Expect 2 turns: assistant text + plan content extracted from tool_result.
+	if len(payload.Turns) != 2 {
+		t.Fatalf("len(Turns) = %d, want 2", len(payload.Turns))
+	}
+
+	// Plan content comes first (extracted from user tool_result, emitted as assistant turn).
+	wantPlan := "# Plan\n\n## Step 1\nDo the thing.\n\n## Step 2\nDo the other thing."
+	if payload.Turns[0].Role != "assistant" {
+		t.Errorf("Turns[0].Role = %q, want assistant", payload.Turns[0].Role)
+	}
+	if payload.Turns[0].Content != "Let me read the plan." {
+		t.Errorf("Turns[0].Content = %q", payload.Turns[0].Content)
+	}
+
+	if payload.Turns[1].Role != "assistant" {
+		t.Errorf("Turns[1].Role = %q, want assistant", payload.Turns[1].Role)
+	}
+	if payload.Turns[1].Content != wantPlan {
+		t.Errorf("Turns[1].Content = %q, want %q", payload.Turns[1].Content, wantPlan)
+	}
+
+	// Tool call should still be captured.
+	if len(payload.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(payload.ToolCalls))
+	}
+	if payload.ToolCalls[0].Tool != "Read" {
+		t.Errorf("ToolCalls[0].Tool = %q, want Read", payload.ToolCalls[0].Tool)
+	}
+}
+
+func TestParseTranscript_PlanReadNonPlanIgnored(t *testing.T) {
+	t.Parallel()
+
+	// Read of a non-plan file should NOT capture the tool_result.
+	input := `{"uuid":"nr1","sessionId":"s6","timestamp":"2025-01-15T10:00:00Z","type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu-read-src","name":"Read","input":{"file_path":"src/main.go"}}]},"gitBranch":"main"}
+{"uuid":"nr2","sessionId":"s6","timestamp":"2025-01-15T10:00:01Z","type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu-read-src","content":"package main\nfunc main() {}"}]},"gitBranch":"main"}`
+
+	payload, err := ParseTranscript([]byte(input))
+	if err != nil {
+		t.Fatalf("ParseTranscript: %v", err)
+	}
+
+	// No turns — non-plan Read result should be discarded, no text blocks.
+	if len(payload.Turns) != 0 {
+		t.Fatalf("len(Turns) = %d, want 0", len(payload.Turns))
+	}
+}
+
 func TestParseTranscript_NonPlanWriteNotCaptured(t *testing.T) {
 	t.Parallel()