@hybridlabor-api/bdb-synapse 1.0.0

package/internal/adapter/claudecode/adapter.go

@@ -0,0 +1,415 @@
+package claudecode
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/hybridlabor-api/bdb-synapse/internal/adapter"
+	"github.com/hybridlabor-api/bdb-synapse/internal/model"
+)
+
+type Adapter struct {
+	Dir string
+}
+
+func DefaultDir() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(home, ".claude", "projects")
+}
+
+func (a Adapter) Harness() string {
+	return "claude-code"
+}
+
+func (a Adapter) SessionDir() string {
+	if a.Dir != "" {
+		return a.Dir
+	}
+	return DefaultDir()
+}
+
+func (a Adapter) ListSessions() ([]model.SessionMeta, error) {
+	dir := a.SessionDir()
+	if info, err := os.Stat(dir); err != nil || !info.IsDir() {
+		return nil, nil
+	}
+	var metas []model.SessionMeta
+	err := filepath.WalkDir(dir, func(path string, entry os.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return nil
+		}
+		if entry.IsDir() {
+			return nil
+		}
+		if filepath.Ext(path) != ".jsonl" || strings.HasPrefix(filepath.Base(path), "agent-") {
+			return nil
+		}
+		meta, err := a.Summarize(path)
+		if err == nil {
+			metas = append(metas, meta)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	sort.Slice(metas, func(i, j int) bool {
+		return metas[i].EndedAt > metas[j].EndedAt
+	})
+	return metas, nil
+}
+
+// SummaryInputs reports the sidecar files Summarize reads for path: child
+// agent sessions carry an agent-*.meta.json describing the spawning tool
+// call, so a sidecar change must invalidate a cached summary.
+func (a Adapter) SummaryInputs(path string) []string {
+	if !strings.HasPrefix(filepath.Base(path), "agent-") {
+		return nil
+	}
+	return []string{strings.TrimSuffix(path, ".jsonl") + ".meta.json"}
+}
+
+func (a Adapter) Summarize(path string) (model.SessionMeta, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return model.SessionMeta{}, err
+	}
+	defer f.Close()
+
+	id := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	meta := model.SessionMeta{Key: adapter.SessionKey(a.Harness(), path), ID: id, Harness: a.Harness(), Path: path}
+	recognized := false
+	err = adapter.ReadJSONLines(f, func(data []byte) {
+		var line rawLine
+		if json.Unmarshal(data, &line) != nil {
+			return
+		}
+		if isClaudeLine(line) {
+			recognized = true
+		}
+		if line.IsSidechain {
+			meta.Auxiliary = true
+			if meta.Agent == nil {
+				meta.Agent = &model.AgentSessionMeta{}
+			}
+			if line.AgentID != "" {
+				meta.ID = line.AgentID
+				meta.Agent.SourceID = line.AgentID
+			}
+			if line.SessionID != "" {
+				meta.Agent.RootSessionID = line.SessionID
+			}
+		} else if line.SessionID != "" && !meta.Auxiliary {
+			meta.ID = line.SessionID
+		}
+		if line.Timestamp != "" {
+			if meta.StartedAt == "" {
+				meta.StartedAt = line.Timestamp
+			}
+			meta.EndedAt = line.Timestamp
+		}
+		if line.Type == "ai-title" && line.AITitle != "" {
+			meta.Title = line.AITitle
+		}
+		if line.Cwd != "" && meta.Cwd == "" {
+			meta.Cwd = line.Cwd
+		}
+		if line.GitBranch != "" && meta.GitBranch == "" {
+			meta.GitBranch = line.GitBranch
+		}
+		if len(line.Message) > 0 {
+			var msg message
+			if json.Unmarshal(line.Message, &msg) == nil {
+				if msg.Model != "" && meta.Model == "" {
+					meta.Model = msg.Model
+				}
+				meta.EventCount += countToolUses(msg.Content)
+				// mirrors Parse's user-message mark filter so the badge's
+				// staleness check counts the same turns the report will
+				if line.Type == "user" && hasUserMessage(msg.Content) && !adapter.InjectedUserMessage(userMessageText(msg.Content)) {
+					meta.UserTurns++
+				}
+			}
+		}
+	})
+	if meta.Auxiliary {
+		var childMeta struct {
+			AgentType   string `json:"agentType"`
+			Description string `json:"description"`
+			ToolUseID   string `json:"toolUseId"`
+			SpawnDepth  int    `json:"spawnDepth"`
+		}
+		data, readErr := os.ReadFile(strings.TrimSuffix(path, ".jsonl") + ".meta.json")
+		if readErr == nil && json.Unmarshal(data, &childMeta) == nil {
+			meta.Agent.Depth = childMeta.SpawnDepth
+			meta.Agent.Label = childMeta.Description
+			meta.Agent.Role = childMeta.AgentType
+			meta.Agent.LaunchCallID = childMeta.ToolUseID
+		}
+	}
+	if meta.Title == "" {
+		meta.Title = filepath.Base(path)
+	}
+	if !recognized {
+		return model.SessionMeta{}, fmt.Errorf("not a Claude Code session: %s", path)
+	}
+	return meta, err
+}
+
+func (a Adapter) Parse(path string) (*model.Trace, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	id := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	trace := &model.Trace{
+		Version: 1,
+		Session: model.TraceSession{
+			ID:      id,
+			Harness: a.Harness(),
+			Path:    path,
+		},
+		Events: []model.Event{},
+		Marks:  []model.Mark{},
+	}
+
+	recognized := false
+	pending := map[string]adapter.ToolCall{}
+	pendingOrder := []string{}
+	err = adapter.ReadJSONLines(f, func(data []byte) {
+		var line rawLine
+		if json.Unmarshal(data, &line) != nil {
+			return
+		}
+		if isClaudeLine(line) {
+			recognized = true
+		}
+		applyLineMeta(trace, line)
+		if line.Type == "ai-title" && line.AITitle != "" {
+			trace.Session.Title = line.AITitle
+			return
+		}
+		if isCompaction(line) {
+			trace.Marks = append(trace.Marks, model.Mark{Seq: len(trace.Events), Type: "compaction"})
+		}
+		if len(line.Message) == 0 {
+			return
+		}
+
+		var msg message
+		if json.Unmarshal(line.Message, &msg) != nil {
+			return
+		}
+		if line.Type == "user" && hasUserMessage(msg.Content) {
+			if text := userMessageText(msg.Content); !adapter.InjectedUserMessage(text) {
+				trace.Marks = append(trace.Marks, model.Mark{
+					Seq:  len(trace.Events),
+					Type: "user-message",
+					Note: adapter.UserMessageNote(text),
+				})
+			}
+		}
+		if msg.Model != "" && trace.Session.Model == "" {
+			trace.Session.Model = msg.Model
+		}
+		for _, item := range msg.Content.Items {
+			switch item.Type {
+			case "tool_use":
+				call := adapter.ToolCall{
+					ID:        item.ID,
+					Name:      item.Name,
+					Input:     item.Input,
+					Timestamp: line.Timestamp,
+				}
+				if call.Name == "Task" || call.Name == "Agent" {
+					trace.Marks = append(trace.Marks, model.Mark{Seq: len(trace.Events), Type: "subagent", Note: call.Name})
+				}
+				if _, exists := pending[call.ID]; !exists {
+					pendingOrder = append(pendingOrder, call.ID)
+				}
+				pending[call.ID] = call
+			case "tool_result":
+				call, ok := pending[item.ToolUseID]
+				if !ok {
+					continue
+				}
+				delete(pending, item.ToolUseID)
+				event := buildEvent(trace, call, item, true)
+				trace.Events = append(trace.Events, event)
+			}
+		}
+	})
+	for _, id := range pendingOrder {
+		if call, ok := pending[id]; ok {
+			trace.Events = append(trace.Events, buildEvent(trace, call, contentItem{}, false))
+		}
+	}
+	sort.Slice(trace.Events, func(i, j int) bool {
+		return trace.Events[i].Seq < trace.Events[j].Seq
+	})
+	for i := range trace.Events {
+		trace.Events[i].Seq = i
+	}
+	trace.Session.EventCount = len(trace.Events)
+	// Claude Code tool results carry an is_error flag set by the harness.
+	trace.Stats = model.ComputeStats(trace, 0, model.ObservabilityExact)
+	if !recognized {
+		return nil, fmt.Errorf("not a Claude Code session: %s", path)
+	}
+	return trace, err
+}
+
+type rawLine struct {
+	Type        string          `json:"type"`
+	Timestamp   string          `json:"timestamp"`
+	SessionID   string          `json:"sessionId"`
+	AgentID     string          `json:"agentId"`
+	IsSidechain bool            `json:"isSidechain"`
+	Cwd         string          `json:"cwd"`
+	GitBranch   string          `json:"gitBranch"`
+	Message     json.RawMessage `json:"message"`
+	AITitle     string          `json:"aiTitle"`
+	Content     string          `json:"content"`
+	Subtype     string          `json:"subtype"`
+}
+
+type message struct {
+	Role    string      `json:"role"`
+	Model   string      `json:"model"`
+	Content contentList `json:"content"`
+}
+
+type contentList struct {
+	Items []contentItem
+}
+
+func (c *contentList) UnmarshalJSON(data []byte) error {
+	if len(data) == 0 || string(data) == "null" {
+		return nil
+	}
+	if data[0] == '"' {
+		var s string
+		if err := json.Unmarshal(data, &s); err != nil {
+			return err
+		}
+		c.Items = []contentItem{{Type: "text", Text: s}}
+		return nil
+	}
+	var items []contentItem
+	if err := json.Unmarshal(data, &items); err != nil {
+		return err
+	}
+	var rawItems []map[string]json.RawMessage
+	if err := json.Unmarshal(data, &rawItems); err != nil {
+		return err
+	}
+	for i := range items {
+		items[i].IsError = nil
+		raw, ok := rawItems[i]["is_error"]
+		if !ok || strings.TrimSpace(string(raw)) == "null" {
+			continue
+		}
+		var value bool
+		if err := json.Unmarshal(raw, &value); err != nil {
+			return err
+		}
+		items[i].IsError = &value
+	}
+	c.Items = items
+	return nil
+}
+
+type contentItem struct {
+	Type      string         `json:"type"`
+	ID        string         `json:"id"`
+	Name      string         `json:"name"`
+	Input     map[string]any `json:"input"`
+	ToolUseID string         `json:"tool_use_id"`
+	Content   any            `json:"content"`
+	IsError   *bool          `json:"is_error"`
+	Text      string         `json:"text"`
+}
+
+func countToolUses(content contentList) int {
+	count := 0
+	for _, item := range content.Items {
+		if item.Type == "tool_use" {
+			count++
+		}
+	}
+	return count
+}
+
+func userMessageText(content contentList) string {
+	var parts []string
+	for _, item := range content.Items {
+		if item.Type == "text" && strings.TrimSpace(item.Text) != "" {
+			parts = append(parts, strings.TrimSpace(item.Text))
+		}
+	}
+	return strings.Join(parts, "\n")
+}
+
+func hasUserMessage(content contentList) bool {
+	if len(content.Items) == 0 {
+		return false
+	}
+	for _, item := range content.Items {
+		if item.Type == "tool_result" {
+			return false
+		}
+		if item.Type == "text" && strings.TrimSpace(item.Text) != "" {
+			return true
+		}
+	}
+	return true
+}
+
+func applyLineMeta(trace *model.Trace, line rawLine) {
+	if line.SessionID != "" {
+		trace.Session.ID = line.SessionID
+	}
+	if line.Cwd != "" && trace.Session.Cwd == "" {
+		trace.Session.Cwd = line.Cwd
+	}
+	if line.Timestamp != "" {
+		if trace.Session.StartedAt == "" {
+			trace.Session.StartedAt = line.Timestamp
+		}
+		trace.Session.EndedAt = line.Timestamp
+	}
+}
+
+func isCompaction(line rawLine) bool {
+	return line.Type == "system" && strings.Contains(strings.ToLower(line.Subtype), "compact")
+}
+
+func isClaudeLine(line rawLine) bool {
+	if line.SessionID != "" {
+		return true
+	}
+	switch line.Type {
+	case "user", "assistant", "system", "ai-title":
+		return line.Timestamp != "" || len(line.Message) > 0
+	default:
+		return false
+	}
+}
+
+func buildEvent(trace *model.Trace, call adapter.ToolCall, result contentItem, resultObserved bool) model.Event {
+	isError := result.IsError != nil && *result.IsError
+	return adapter.BuildEvent(trace, call, adapter.ToolResult{
+		Content:      adapter.ContentToString(result.Content),
+		IsError:      isError,
+		OutcomeKnown: resultObserved,
+	})
+}

package/internal/adapter/claudecode/adapter_test.go

@@ -0,0 +1,260 @@
+package claudecode
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestParseSession(t *testing.T) {
+	trace, err := (Adapter{}).Parse(filepath.Join("..", "..", "..", "testdata", "claude-session.jsonl"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if trace.Session.ID != "demo-session" {
+		t.Fatalf("session id = %q", trace.Session.ID)
+	}
+	if trace.Session.Title != "Demo trace" {
+		t.Fatalf("title = %q", trace.Session.Title)
+	}
+	if trace.Session.Model != "claude-test" {
+		t.Fatalf("model = %q", trace.Session.Model)
+	}
+	if len(trace.Events) != 2 {
+		t.Fatalf("events = %d", len(trace.Events))
+	}
+	read := trace.Events[0]
+	if read.Action != "read" || len(read.Targets) != 1 || read.Targets[0].Path != "src/main.go" {
+		t.Fatalf("bad read event: %#v", read)
+	}
+	if got := read.Targets[0].Lines[0]; got != [2]int{10, 14} {
+		t.Fatalf("line range = %#v", got)
+	}
+	edit := trace.Events[1]
+	if edit.Action != "edit" || edit.Targets[0].Touch != "edit" {
+		t.Fatalf("bad edit event: %#v", edit)
+	}
+	if trace.Stats.Edited != 1 || trace.Stats.Fovea != 1 {
+		t.Fatalf("stats = %#v", trace.Stats)
+	}
+}
+
+func TestParseSkipsBashNoiseAndKeepsExistingWeakPaths(t *testing.T) {
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "src"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "src", "main.go"), []byte("package main\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	session := filepath.Join(t.TempDir(), "session.jsonl")
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","cwd":`+quote(root)+`,"sessionId":"noise","message":{"role":"user","content":"x"}}`,
+		`{"type":"assistant","timestamp":"2026-07-09T00:00:01Z","cwd":`+quote(root)+`,"sessionId":"noise","message":{"role":"assistant","content":[{"type":"tool_use","id":"bash","name":"Bash","input":{"command":"printf 'please check the main.go file\nupdated to v1.5\n+ cs.fontSize = 27.2px\nsrc/main.go\n'"}}]}}`,
+		`{"type":"user","timestamp":"2026-07-09T00:00:02Z","cwd":`+quote(root)+`,"sessionId":"noise","message":{"role":"user","content":[{"tool_use_id":"bash","type":"tool_result","content":"please check the main.go file\nupdated to v1.5\n+ cs.fontSize = 27.2px\nsrc/main.go\n","is_error":false}]}}`,
+	)
+	trace, err := (Adapter{}).Parse(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(trace.Events) != 1 {
+		t.Fatalf("events = %d", len(trace.Events))
+	}
+	targets := trace.Events[0].Targets
+	if len(targets) != 1 {
+		t.Fatalf("targets = %#v", targets)
+	}
+	if targets[0].Path != "src/main.go" || !targets[0].Weak {
+		t.Fatalf("target = %#v", targets[0])
+	}
+}
+
+func TestParsePendingToolUsesRemainDeterministic(t *testing.T) {
+	session := filepath.Join(t.TempDir(), "pending.jsonl")
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","cwd":"/tmp","sessionId":"pending","message":{"role":"user","content":"x"}}`,
+		`{"type":"assistant","timestamp":"2026-07-09T00:00:01Z","cwd":"/tmp","sessionId":"pending","message":{"role":"assistant","content":[{"type":"tool_use","id":"a","name":"Read","input":{"file_path":"/tmp/a.go"}},{"type":"tool_use","id":"b","name":"Read","input":{"file_path":"/tmp/b.go"}},{"type":"tool_use","id":"c","name":"Read","input":{"file_path":"/tmp/c.go"}}]}}`,
+	)
+	for i := 0; i < 20; i++ {
+		trace, err := (Adapter{}).Parse(session)
+		if err != nil {
+			t.Fatal(err)
+		}
+		got := []string{trace.Events[0].Targets[0].Path, trace.Events[1].Targets[0].Path, trace.Events[2].Targets[0].Path}
+		want := []string{"a.go", "b.go", "c.go"}
+		for j := range want {
+			if got[j] != want[j] {
+				t.Fatalf("run %d order = %#v", i, got)
+			}
+		}
+	}
+}
+
+func TestParsePreservesToolOutcomeCertainty(t *testing.T) {
+	session := filepath.Join(t.TempDir(), "outcome-certainty.jsonl")
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","cwd":"/tmp","sessionId":"outcome-certainty","message":{"role":"user","content":"x"}}`,
+		`{"type":"assistant","timestamp":"2026-07-09T00:00:01Z","cwd":"/tmp","sessionId":"outcome-certainty","message":{"role":"assistant","content":[{"type":"tool_use","id":"explicit-success","name":"Bash","input":{"command":"go test ./..."}},{"type":"tool_use","id":"failure","name":"Bash","input":{"command":"make test"}},{"type":"tool_use","id":"implicit-success","name":"Bash","input":{"command":"npm test"}},{"type":"tool_use","id":"wrong-case","name":"Bash","input":{"command":"go test ./internal/..."}},{"type":"tool_use","id":"pending","name":"Bash","input":{"command":"go vet ./..."}}]}}`,
+		`{"type":"user","timestamp":"2026-07-09T00:00:02Z","cwd":"/tmp","sessionId":"outcome-certainty","message":{"role":"user","content":[{"tool_use_id":"explicit-success","type":"tool_result","content":"ok","is_error":false},{"tool_use_id":"failure","type":"tool_result","content":"failed","is_error":true},{"tool_use_id":"implicit-success","type":"tool_result","content":"ok"},{"tool_use_id":"wrong-case","type":"tool_result","content":"ok","IS_ERROR":true}]}}`,
+	)
+
+	trace, err := (Adapter{}).Parse(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(trace.Events) != 5 {
+		t.Fatalf("events = %#v", trace.Events)
+	}
+	if got := trace.Events[0]; !got.OutcomeKnown || got.IsError {
+		t.Fatalf("success event = %#v", got)
+	}
+	if got := trace.Events[1]; !got.OutcomeKnown || !got.IsError {
+		t.Fatalf("failure event = %#v", got)
+	}
+	if got := trace.Events[2]; !got.OutcomeKnown || got.IsError {
+		t.Fatalf("implicit success event = %#v", got)
+	}
+	if got := trace.Events[3]; !got.OutcomeKnown || got.IsError {
+		t.Fatalf("wrong-case error key event = %#v", got)
+	}
+	if got := trace.Events[4]; got.OutcomeKnown || got.IsError {
+		t.Fatalf("pending event = %#v", got)
+	}
+	if trace.Stats.Observability.Errors != "estimated" {
+		t.Fatalf("observability = %#v", trace.Stats.Observability)
+	}
+}
+
+func TestCompactionUsesSubtypeOnly(t *testing.T) {
+	session := filepath.Join(t.TempDir(), "compact.jsonl")
+	writeSession(t, session,
+		`{"type":"system","subtype":"local_command","content":"compact but not a boundary","timestamp":"2026-07-09T00:00:00Z","sessionId":"compact"}`,
+		`{"type":"system","subtype":"compact_boundary","content":"","timestamp":"2026-07-09T00:00:01Z","sessionId":"compact"}`,
+	)
+	trace, err := (Adapter{}).Parse(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(trace.Marks) != 1 || trace.Marks[0].Type != "compaction" {
+		t.Fatalf("marks = %#v", trace.Marks)
+	}
+}
+
+func TestUserMessageMarkCarriesNote(t *testing.T) {
+	long := strings.Repeat("字", 2100)
+	session := filepath.Join(t.TempDir(), "notes.jsonl")
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","cwd":"/tmp","sessionId":"notes","message":{"role":"user","content":"fix the login bug"}}`,
+		`{"type":"assistant","timestamp":"2026-07-09T00:00:01Z","cwd":"/tmp","sessionId":"notes","message":{"role":"assistant","content":[{"type":"tool_use","id":"a","name":"Read","input":{"file_path":"/tmp/a.go"}}]}}`,
+		`{"type":"user","timestamp":"2026-07-09T00:00:02Z","cwd":"/tmp","sessionId":"notes","message":{"role":"user","content":[{"tool_use_id":"a","type":"tool_result","content":"ok","is_error":false}]}}`,
+		`{"type":"user","timestamp":"2026-07-09T00:00:03Z","cwd":"/tmp","sessionId":"notes","message":{"role":"user","content":"`+long+`"}}`,
+	)
+	trace, err := (Adapter{}).Parse(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(trace.Marks) != 2 {
+		t.Fatalf("marks = %#v", trace.Marks)
+	}
+	if trace.Marks[0].Note != "fix the login bug" {
+		t.Fatalf("note = %q", trace.Marks[0].Note)
+	}
+	// The ellipsis fits inside the 2000-rune budget the schema promises.
+	truncated := []rune(trace.Marks[1].Note)
+	if len(truncated) != 2000 || truncated[len(truncated)-1] != '…' {
+		t.Fatalf("truncated note runes = %d, last = %q", len(truncated), truncated[len(truncated)-1])
+	}
+	// Summarize counts the same turns Parse marks — tool results and other
+	// non-message user lines stay out of both.
+	meta, err := (Adapter{}).Summarize(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if meta.UserTurns != 2 {
+		t.Fatalf("summarized userTurns = %d, want 2", meta.UserTurns)
+	}
+}
+
+func TestSummarizeRecognizesUnknownClaudeLineWithSessionID(t *testing.T) {
+	session := filepath.Join(t.TempDir(), "metadata.jsonl")
+	writeSession(t, session,
+		`{"type":"metadata","timestamp":"2026-07-09T00:00:00Z","sessionId":"metadata-session","cwd":"/tmp"}`,
+	)
+	meta, err := (Adapter{}).Summarize(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if meta.ID != "metadata-session" || meta.Cwd != "/tmp" {
+		t.Fatalf("meta = %#v", meta)
+	}
+}
+
+func TestSummarizePopulatesSidechainMetadata(t *testing.T) {
+	rootDir := filepath.Join(t.TempDir(), "root-session", "subagents")
+	if err := os.MkdirAll(rootDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	session := filepath.Join(rootDir, "agent-child.jsonl")
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","sessionId":"root-session","agentId":"child","isSidechain":true,"cwd":"/tmp","message":{"role":"user","content":"hello"}}`,
+	)
+	if err := os.WriteFile(strings.TrimSuffix(session, ".jsonl")+".meta.json", []byte(`{"agentType":"Explore","description":"Inspect child","toolUseId":"call-child","spawnDepth":2}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	meta, err := (Adapter{}).Summarize(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if meta.ID != "child" {
+		t.Fatalf("id = %q, want child", meta.ID)
+	}
+	if !meta.Auxiliary || meta.Agent == nil {
+		t.Fatalf("meta = %#v", meta)
+	}
+	if meta.Agent.SourceID != "child" || meta.Agent.RootSessionID != "root-session" || meta.Agent.Depth != 2 ||
+		meta.Agent.Role != "Explore" || meta.Agent.LaunchCallID != "call-child" {
+		t.Fatalf("agent meta = %#v", *meta.Agent)
+	}
+}
+
+func TestSummarizeHandlesLargeJSONLines(t *testing.T) {
+	dir := t.TempDir()
+	session := filepath.Join(dir, "large.jsonl")
+	largeText := strings.Repeat("x", 21*1024*1024)
+	writeSession(t, session,
+		`{"type":"user","timestamp":"2026-07-09T00:00:00Z","cwd":"/tmp","sessionId":"large","message":{"role":"user","content":"`+largeText+`"}}`,
+	)
+
+	adapter := Adapter{Dir: dir}
+	meta, err := adapter.Summarize(session)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if meta.ID != "large" {
+		t.Fatalf("id = %q", meta.ID)
+	}
+	sessions, err := adapter.ListSessions()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sessions) != 1 || sessions[0].ID != "large" {
+		t.Fatalf("sessions = %#v", sessions)
+	}
+}
+
+func writeSession(t *testing.T, path string, lines ...string) {
+	t.Helper()
+	content := ""
+	for _, line := range lines {
+		content += line + "\n"
+	}
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func quote(s string) string {
+	return `"` + filepath.ToSlash(s) + `"`
+}