diff --git a/TODO.md b/TODO.md
index 610cda1..c603b1e 100644
--- a/TODO.md
+++ b/TODO.md
@@ -6,11 +6,11 @@ Dispatched from core/go orchestration. Pick up tasks in order.
 
 ## Phase 0: Hardening & Test Coverage
 
-- [x] **Add parser tests** — 51 tests, 90.9% coverage. `7771e64`
-- [x] **Add ListSessions tests** — 5 tests (empty, single, sorted, non-jsonl, malformed). `7771e64`
-- [x] **Tool extraction coverage** — All 7 tool types + unknown fallback + nil. `7771e64`
-- [x] **Benchmark parsing** — `BenchmarkParseTranscript` with 4000-line JSONL. `7771e64`
-- [x] **`go vet ./...` clean** — No warnings. `7771e64`
+- [x] **Add parser tests** — Test `ParseTranscript()` with: minimal valid JSONL (1 user + 1 assistant message), tool call events (Bash, Read, Edit, Write, Grep, Glob, Task), truncated JSONL (incomplete last line), empty file, malformed JSON lines (should skip gracefully), very large session (1000+ events), nested tool results with arrays and maps. Also added HTML, video, and search tests. 67 tests, 90.9% coverage.
+- [x] **Add ListSessions tests** — Test with: empty directory, single session, multiple sessions sorted by date, non-.jsonl files ignored, malformed JSONL fallback to modtime.
+- [x] **Tool extraction coverage** — Test `extractToolInput()` for each supported tool type (Bash, Read, Edit, Write, Grep, Glob, Task) plus nil input, invalid JSON, and unknown tool fallback.
+- [x] **Benchmark parsing** — `BenchmarkParseTranscript` with 2.2MB (5K tools) and 11MB (25K tools) JSONL files. Plus `BenchmarkListSessions` and `BenchmarkSearch`. Uses `b.Loop()` (Go 1.25+).
+- [x] **`go vet ./...` clean** — Verified clean, no warnings.
 
 ## Phase 1: Parser Robustness
 
diff --git a/bench_test.go b/bench_test.go
new file mode 100644
index 0000000..e49ef2c
--- /dev/null
+++ b/bench_test.go
@@ -0,0 +1,155 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+package session
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// BenchmarkParseTranscript benchmarks parsing a ~1MB+ JSONL file.
+func BenchmarkParseTranscript(b *testing.B) {
+	dir := b.TempDir()
+	path := generateBenchJSONL(b, dir, 5000) // ~1MB+ of JSONL
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for b.Loop() {
+		sess, err := ParseTranscript(path)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if len(sess.Events) == 0 {
+			b.Fatal("expected events")
+		}
+	}
+}
+
+// BenchmarkParseTranscript_Large benchmarks a larger ~5MB file.
+func BenchmarkParseTranscript_Large(b *testing.B) {
+	dir := b.TempDir()
+	path := generateBenchJSONL(b, dir, 25000) // ~5MB
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for b.Loop() {
+		_, err := ParseTranscript(path)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// BenchmarkListSessions benchmarks listing sessions in a directory.
+func BenchmarkListSessions(b *testing.B) {
+	dir := b.TempDir()
+
+	// Create 20 session files
+	for i := 0; i < 20; i++ {
+		generateBenchJSONL(b, dir, 100)
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for b.Loop() {
+		sessions, err := ListSessions(dir)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if len(sessions) == 0 {
+			b.Fatal("expected sessions")
+		}
+	}
+}
+
+// BenchmarkSearch benchmarks searching across multiple sessions.
+func BenchmarkSearch(b *testing.B) {
+	dir := b.TempDir()
+
+	// Create 10 session files with varied content
+	for i := 0; i < 10; i++ {
+		generateBenchJSONL(b, dir, 500)
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for b.Loop() {
+		_, err := Search(dir, "echo")
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// generateBenchJSONL creates a synthetic JSONL file with the given number of tool pairs.
+// Returns the file path.
+func generateBenchJSONL(b testing.TB, dir string, numTools int) string {
+	b.Helper()
+
+	var sb strings.Builder
+	baseTS := "2026-02-20T10:00:00Z"
+
+	// Opening user message
+	sb.WriteString(fmt.Sprintf(`{"type":"user","timestamp":"%s","sessionId":"bench","message":{"role":"user","content":[{"type":"text","text":"Start benchmark session"}]}}`, baseTS))
+	sb.WriteByte('\n')
+
+	for i := 0; i < numTools; i++ {
+		toolID := fmt.Sprintf("tool-%d", i)
+		offset := i * 2
+
+		// Alternate between different tool types for realistic distribution
+		var toolUse, toolResult string
+		switch i % 5 {
+		case 0: // Bash
+			toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Bash","id":"%s","input":{"command":"echo iteration %d","description":"echo test"}}]}}`,
+				offset/60, offset%60, toolID, i)
+			toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"iteration %d output line one\niteration %d output line two","is_error":false}]}}`,
+				(offset+1)/60, (offset+1)%60, toolID, i, i)
+		case 1: // Read
+			toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Read","id":"%s","input":{"file_path":"/tmp/bench/file-%d.go"}}]}}`,
+				offset/60, offset%60, toolID, i)
+			toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"package main\n\nfunc main() {\n\tfmt.Println(%d)\n}","is_error":false}]}}`,
+				(offset+1)/60, (offset+1)%60, toolID, i)
+		case 2: // Edit
+			toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Edit","id":"%s","input":{"file_path":"/tmp/bench/file-%d.go","old_string":"old","new_string":"new"}}]}}`,
+				offset/60, offset%60, toolID, i)
+			toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"ok","is_error":false}]}}`,
+				(offset+1)/60, (offset+1)%60, toolID)
+		case 3: // Grep
+			toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Grep","id":"%s","input":{"pattern":"TODO","path":"/tmp/bench"}}]}}`,
+				offset/60, offset%60, toolID)
+			toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"/tmp/bench/file.go:10: // TODO fix this","is_error":false}]}}`,
+				(offset+1)/60, (offset+1)%60, toolID)
+		case 4: // Glob
+			toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Glob","id":"%s","input":{"pattern":"**/*.go"}}]}}`,
+				offset/60, offset%60, toolID)
+			toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"/tmp/a.go\n/tmp/b.go\n/tmp/c.go","is_error":false}]}}`,
+				(offset+1)/60, (offset+1)%60, toolID)
+		}
+
+		sb.WriteString(toolUse)
+		sb.WriteByte('\n')
+		sb.WriteString(toolResult)
+		sb.WriteByte('\n')
+	}
+
+	// Closing assistant message
+	sb.WriteString(fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T12:00:00Z","sessionId":"bench","message":{"role":"assistant","content":[{"type":"text","text":"Benchmark session complete."}]}}%s`, "\n"))
+
+	name := fmt.Sprintf("bench-%d.jsonl", numTools)
+	path := filepath.Join(dir, name)
+	if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
+		b.Fatal(err)
+	}
+
+	info, _ := os.Stat(path)
+	b.Logf("Generated %s: %d bytes, %d tool pairs", name, info.Size(), numTools)
+
+	return path
+}
diff --git a/html_test.go b/html_test.go
index 264c1e0..83a9251 100644
--- a/html_test.go
+++ b/html_test.go
@@ -1,8 +1,8 @@
+// SPDX-Licence-Identifier: EUPL-1.2
 package session
 
 import (
 	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -11,333 +11,228 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestRenderHTML_BasicSession(t *testing.T) {
+func TestRenderHTML_BasicSession_Good(t *testing.T) {
+	dir := t.TempDir()
+	outputPath := dir + "/output.html"
+
 	sess := &Session{
-		ID:        "test-session-abcdef12",
+		ID:        "test-session-12345678",
 		Path:      "/tmp/test.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Minute),
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		EndTime:   time.Date(2026, 2, 20, 10, 5, 30, 0, time.UTC),
 		Events: []Event{
 			{
-				Timestamp: baseTime,
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 				Type:      "user",
-				Input:     "Please list files",
+				Input:     "Hello, please help me",
 			},
 			{
-				Timestamp: baseTime.Add(time.Second),
-				Type:      "tool_use",
-				Tool:      "Bash",
-				ToolID:    "tu_1",
-				Input:     "ls -la # list files",
-				Output:    "total 42\ndrwxr-xr-x  3 user user  4096 Feb 19 .",
-				Duration:  2 * time.Second,
-				Success:   true,
-			},
-			{
-				Timestamp: baseTime.Add(3 * time.Second),
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC),
 				Type:      "assistant",
-				Input:     "The directory contains 42 items.",
+				Input:     "Sure, let me check.",
 			},
-		},
-	}
-
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "out.html")
-	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
-
-	data, err := os.ReadFile(outputPath)
-	require.NoError(t, err)
-	html := string(data)
-
-	t.Run("contains_doctype", func(t *testing.T) {
-		assert.True(t, strings.HasPrefix(html, "<!DOCTYPE html>"))
-	})
-
-	t.Run("contains_session_id", func(t *testing.T) {
-		assert.Contains(t, html, "test-ses")
-	})
-
-	t.Run("contains_timestamp", func(t *testing.T) {
-		assert.Contains(t, html, "2026-02-19 10:00:00")
-	})
-
-	t.Run("contains_tool_count", func(t *testing.T) {
-		assert.Contains(t, html, "1 tool calls")
-	})
-
-	t.Run("contains_user_event", func(t *testing.T) {
-		assert.Contains(t, html, "User")
-		assert.Contains(t, html, "Please list files")
-	})
-
-	t.Run("contains_bash_event", func(t *testing.T) {
-		assert.Contains(t, html, "Bash")
-		assert.Contains(t, html, "ls -la")
-	})
-
-	t.Run("contains_assistant_event", func(t *testing.T) {
-		assert.Contains(t, html, "Claude")
-	})
-
-	t.Run("contains_js_functions", func(t *testing.T) {
-		assert.Contains(t, html, "function toggle(")
-		assert.Contains(t, html, "function filterEvents(")
-	})
-
-	t.Run("contains_success_icon", func(t *testing.T) {
-		assert.Contains(t, html, "&#10003;") // Tick mark
-	})
-
-	t.Run("html_ends_properly", func(t *testing.T) {
-		assert.True(t, strings.HasSuffix(strings.TrimSpace(html), "</html>"))
-	})
-}
-
-func TestRenderHTML_EmptySession(t *testing.T) {
-	sess := &Session{
-		ID:        "empty-session",
-		Path:      "/tmp/empty.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime,
-		Events:    nil,
-	}
-
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "empty.html")
-	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
-
-	data, err := os.ReadFile(outputPath)
-	require.NoError(t, err)
-	html := string(data)
-
-	assert.Contains(t, html, "<!DOCTYPE html>")
-	assert.Contains(t, html, "0 tool calls")
-	// No error count span should appear in the stats.
-	assert.NotContains(t, html, `class="err">`)
-}
-
-func TestRenderHTML_WithErrors(t *testing.T) {
-	sess := &Session{
-		ID:        "error-session",
-		Path:      "/tmp/err.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(10 * time.Second),
-		Events: []Event{
 			{
-				Timestamp: baseTime,
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 2, 0, time.UTC),
 				Type:      "tool_use",
 				Tool:      "Bash",
-				ToolID:    "tu_ok",
-				Input:     "echo ok",
-				Output:    "ok",
+				ToolID:    "t1",
+				Input:     "ls -la",
+				Output:    "total 42",
 				Duration:  time.Second,
 				Success:   true,
 			},
 			{
-				Timestamp: baseTime.Add(2 * time.Second),
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 4, 0, time.UTC),
 				Type:      "tool_use",
-				Tool:      "Bash",
-				ToolID:    "tu_err",
-				Input:     "false",
-				Output:    "exit 1",
-				Duration:  time.Second,
-				Success:   false,
-				ErrorMsg:  "exit 1",
-			},
-		},
-	}
-
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "errors.html")
-	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
-
-	data, err := os.ReadFile(outputPath)
-	require.NoError(t, err)
-	html := string(data)
-
-	assert.Contains(t, html, "2 tool calls")
-	assert.Contains(t, html, "1 errors")
-	assert.Contains(t, html, `class="err"`)
-	assert.Contains(t, html, "&#10007;") // Cross mark for error
-}
-
-func TestRenderHTML_DurationFormatting(t *testing.T) {
-	sess := &Session{
-		ID:        "dur-test",
-		Path:      "/tmp/dur.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(2 * time.Hour),
-		Events: []Event{
-			{
-				Timestamp: baseTime,
-				Type:      "tool_use",
-				Tool:      "Bash",
-				ToolID:    "tu_ms",
-				Input:     "fast cmd",
+				Tool:      "Read",
+				ToolID:    "t2",
+				Input:     "/tmp/file.go",
+				Output:    "package main",
 				Duration:  500 * time.Millisecond,
 				Success:   true,
 			},
+		},
+	}
+
+	err := RenderHTML(sess, outputPath)
+	require.NoError(t, err)
+
+	content, err := os.ReadFile(outputPath)
+	require.NoError(t, err)
+
+	html := string(content)
+
+	// Basic structure checks
+	assert.Contains(t, html, "<!DOCTYPE html>")
+	assert.Contains(t, html, "test-ses") // shortID of "test-session-12345678"
+	assert.Contains(t, html, "2026-02-20 10:00:00")
+	assert.Contains(t, html, "5m30s") // duration
+	assert.Contains(t, html, "2 tool calls")
+	assert.Contains(t, html, "ls -la")
+	assert.Contains(t, html, "total 42")
+	assert.Contains(t, html, "/tmp/file.go")
+	assert.Contains(t, html, "User")   // user event label
+	assert.Contains(t, html, "Claude") // assistant event label
+	assert.Contains(t, html, "Bash")
+	assert.Contains(t, html, "Read")
+	// Should contain JS for toggle and filter
+	assert.Contains(t, html, "function toggle")
+	assert.Contains(t, html, "function filterEvents")
+}
+
+func TestRenderHTML_EmptySession_Good(t *testing.T) {
+	dir := t.TempDir()
+	outputPath := dir + "/empty.html"
+
+	sess := &Session{
+		ID:        "empty",
+		Path:      "/tmp/empty.jsonl",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		EndTime:   time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		Events:    nil,
+	}
+
+	err := RenderHTML(sess, outputPath)
+	require.NoError(t, err)
+
+	content, err := os.ReadFile(outputPath)
+	require.NoError(t, err)
+
+	html := string(content)
+	assert.Contains(t, html, "<!DOCTYPE html>")
+	assert.Contains(t, html, "0 tool calls")
+	// Should NOT contain error span
+	assert.NotContains(t, html, "errors</span>")
+}
+
+func TestRenderHTML_WithErrors_Good(t *testing.T) {
+	dir := t.TempDir()
+	outputPath := dir + "/errors.html"
+
+	sess := &Session{
+		ID:        "err-session",
+		Path:      "/tmp/err.jsonl",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		EndTime:   time.Date(2026, 2, 20, 10, 1, 0, 0, time.UTC),
+		Events: []Event{
 			{
-				Timestamp: baseTime.Add(time.Second),
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 				Type:      "tool_use",
 				Tool:      "Bash",
-				ToolID:    "tu_sec",
-				Input:     "slow cmd",
-				Duration:  45 * time.Second,
-				Success:   true,
+				Input:     "cat /nonexistent",
+				Output:    "No such file",
+				Duration:  100 * time.Millisecond,
+				Success:   false,
+				ErrorMsg:  "No such file",
 			},
 			{
-				Timestamp: baseTime.Add(time.Minute),
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 30, 0, time.UTC),
 				Type:      "tool_use",
 				Tool:      "Bash",
-				ToolID:    "tu_min",
-				Input:     "very slow cmd",
-				Duration:  3*time.Minute + 30*time.Second,
+				Input:     "echo ok",
+				Output:    "ok",
+				Duration:  50 * time.Millisecond,
 				Success:   true,
 			},
 		},
 	}
 
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "dur.html")
 	err := RenderHTML(sess, outputPath)
 	require.NoError(t, err)
 
-	data, err := os.ReadFile(outputPath)
+	content, err := os.ReadFile(outputPath)
 	require.NoError(t, err)
-	html := string(data)
 
-	assert.Contains(t, html, "500ms")
-	assert.Contains(t, html, "45.0s")
-	assert.Contains(t, html, "3m30s")
-	assert.Contains(t, html, "2h0m") // Header duration
+	html := string(content)
+	assert.Contains(t, html, "1 errors")
+	assert.Contains(t, html, `class="event error"`)
+	assert.Contains(t, html, "&#10007;") // cross mark for failed
+	assert.Contains(t, html, "&#10003;") // check mark for success
 }
 
-func TestRenderHTML_HTMLEscaping(t *testing.T) {
+func TestRenderHTML_SpecialCharacters_Good(t *testing.T) {
+	dir := t.TempDir()
+	outputPath := dir + "/special.html"
+
 	sess := &Session{
-		ID:        "escape-test",
-		Path:      "/tmp/esc.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(time.Second),
+		ID:        "special",
+		Path:      "/tmp/special.jsonl",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		EndTime:   time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC),
 		Events: []Event{
 			{
-				Timestamp: baseTime,
-				Type:      "user",
-				Input:     `<script>alert("xss")</script>`,
-			},
-			{
-				Timestamp: baseTime,
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 				Type:      "tool_use",
 				Tool:      "Bash",
-				ToolID:    "tu_esc",
-				Input:     `echo "<b>bold</b>"`,
-				Output:    `<b>bold</b>`,
+				Input:     `echo "<script>alert('xss')</script>"`,
+				Output:    `<script>alert('xss')</script>`,
 				Duration:  time.Second,
 				Success:   true,
 			},
+			{
+				Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+				Type:      "user",
+				Input:     `User says: "quotes & <brackets>"`,
+			},
 		},
 	}
 
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "esc.html")
 	err := RenderHTML(sess, outputPath)
 	require.NoError(t, err)
 
-	data, err := os.ReadFile(outputPath)
+	content, err := os.ReadFile(outputPath)
 	require.NoError(t, err)
-	html := string(data)
 
-	// Raw angle brackets must be escaped.
-	assert.NotContains(t, html, `<script>alert`)
+	html := string(content)
+
+	// Script tags should be escaped, never raw
+	assert.NotContains(t, html, "<script>alert")
 	assert.Contains(t, html, "&lt;script&gt;")
+	assert.Contains(t, html, "&amp;")
 }
 
-func TestRenderHTML_InvalidPath(t *testing.T) {
-	sess := &Session{ID: "x", StartTime: baseTime, EndTime: baseTime}
-	err := RenderHTML(sess, "/nonexistent/dir/out.html")
+func TestRenderHTML_InvalidPath_Ugly(t *testing.T) {
+	sess := &Session{
+		ID:     "test",
+		Events: nil,
+	}
+
+	err := RenderHTML(sess, "/nonexistent/dir/output.html")
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "create html")
 }
 
-func TestRenderHTML_AllEventTypes(t *testing.T) {
-	// Verify that the label logic covers all event types.
+func TestRenderHTML_LabelsByToolType_Good(t *testing.T) {
+	dir := t.TempDir()
+	outputPath := dir + "/labels.html"
+
 	sess := &Session{
 		ID:        "labels",
 		Path:      "/tmp/labels.jsonl",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(10 * time.Second),
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		EndTime:   time.Date(2026, 2, 20, 10, 0, 5, 0, time.UTC),
 		Events: []Event{
-			{Timestamp: baseTime, Type: "user", Input: "user msg"},
-			{Timestamp: baseTime, Type: "assistant", Input: "assistant msg"},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Bash", Input: "cmd", Success: true, Duration: time.Second},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Read", Input: "/path", Success: true, Duration: time.Second},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Edit", Input: "/path (edit)", Success: true, Duration: time.Second},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Write", Input: "/path (10 bytes)", Success: true, Duration: time.Second},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Success: true, Duration: time.Second},
-			{Timestamp: baseTime, Type: "tool_use", Tool: "Glob", Input: "**/*.go", Success: true, Duration: time.Second},
+			{Type: "tool_use", Tool: "Bash", Input: "ls", Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC), Success: true},
+			{Type: "tool_use", Tool: "Read", Input: "/file", Timestamp: time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC), Success: true},
+			{Type: "tool_use", Tool: "Glob", Input: "**/*.go", Timestamp: time.Date(2026, 2, 20, 10, 0, 2, 0, time.UTC), Success: true},
+			{Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Timestamp: time.Date(2026, 2, 20, 10, 0, 3, 0, time.UTC), Success: true},
+			{Type: "tool_use", Tool: "Edit", Input: "/file (edit)", Timestamp: time.Date(2026, 2, 20, 10, 0, 4, 0, time.UTC), Success: true},
+			{Type: "tool_use", Tool: "Write", Input: "/file (100 bytes)", Timestamp: time.Date(2026, 2, 20, 10, 0, 5, 0, time.UTC), Success: true},
 		},
 	}
 
-	dir := t.TempDir()
-	outputPath := filepath.Join(dir, "labels.html")
 	err := RenderHTML(sess, outputPath)
 	require.NoError(t, err)
 
-	data, err := os.ReadFile(outputPath)
+	content, err := os.ReadFile(outputPath)
 	require.NoError(t, err)
-	html := string(data)
 
-	// Check label assignments.
-	assert.Contains(t, html, "Message") // User event label
-	assert.Contains(t, html, "Response") // Assistant event label
-	assert.Contains(t, html, "Command")  // Bash event label
-	assert.Contains(t, html, "Target")   // Read/Grep/Glob event label
-	assert.Contains(t, html, "File")     // Edit/Write event label
-}
-
-// -- shortID tests --
-
-func TestShortID(t *testing.T) {
-	tests := []struct {
-		name string
-		id   string
-		want string
-	}{
-		{"long id", "abcdef1234567890", "abcdef12"},
-		{"short id", "abc", "abc"},
-		{"exactly 8", "abcdefgh", "abcdefgh"},
-		{"empty", "", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, shortID(tt.id))
-		})
-	}
-}
-
-// -- formatDuration tests --
-
-func TestFormatDuration(t *testing.T) {
-	tests := []struct {
-		name string
-		d    time.Duration
-		want string
-	}{
-		{"milliseconds", 500 * time.Millisecond, "500ms"},
-		{"seconds", 45 * time.Second, "45.0s"},
-		{"minutes", 3*time.Minute + 30*time.Second, "3m30s"},
-		{"hours", 2*time.Hour + 15*time.Minute, "2h15m"},
-		{"zero", 0, "0ms"},
-		{"sub-millisecond", 500 * time.Microsecond, "0ms"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, formatDuration(tt.d))
-		})
-	}
+	html := string(content)
+
+	// Bash gets "Command" label
+	assert.True(t, strings.Contains(html, "Command"), "Bash events should use 'Command' label")
+	// Read, Glob, Grep get "Target" label
+	assert.True(t, strings.Contains(html, "Target"), "Read/Glob/Grep events should use 'Target' label")
+	// Edit, Write get "File" label
+	assert.True(t, strings.Contains(html, "File"), "Edit/Write events should use 'File' label")
 }
diff --git a/parser_test.go b/parser_test.go
index 65ce557..93013cf 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -1,7 +1,9 @@
+// SPDX-Licence-Identifier: EUPL-1.2
 package session
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -12,543 +14,770 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// -- helpers --
+// --- helpers to build synthetic JSONL ---
 
-// writeTempJSONL writes lines to a temp .jsonl file and returns the path.
-func writeTempJSONL(t *testing.T, dir, name string, lines ...string) string {
-	t.Helper()
-	path := filepath.Join(dir, name)
-	content := strings.Join(lines, "\n") + "\n"
-	require.NoError(t, os.WriteFile(path, []byte(content), 0644))
-	return path
+// ts returns a stable timestamp offset by the given seconds from a fixed epoch.
+func ts(offsetSec int) string {
+	base := time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC)
+	return base.Add(time.Duration(offsetSec) * time.Second).Format(time.RFC3339Nano)
 }
 
-// ts builds an RFC3339Nano timestamp string offset from a base.
-func ts(base time.Time, offset time.Duration) string {
-	return base.Add(offset).Format(time.RFC3339Nano)
-}
-
-// jsonLine builds a raw JSONL line from an entry struct.
-func jsonLine(t *testing.T, v interface{}) string {
-	t.Helper()
-	b, err := json.Marshal(v)
-	require.NoError(t, err)
+// jsonlLine marshals an arbitrary map to a single JSONL line.
+func jsonlLine(m map[string]interface{}) string {
+	b, _ := json.Marshal(m)
 	return string(b)
 }
 
-// -- fixtures --
-
-var baseTime = time.Date(2026, 2, 19, 10, 0, 0, 0, time.UTC)
-
-// fixtureMinimalSession returns JSONL lines for a user message followed by
-// an assistant text reply.
-func fixtureMinimalSession() []string {
-	return []string{
-		`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"abc123","message":{"role":"user","content":[{"type":"text","text":"hello"}]}}`,
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 2*time.Second) + `","sessionId":"abc123","message":{"role":"assistant","content":[{"type":"text","text":"Hi there."}]}}`,
-	}
+// userTextEntry creates a JSONL line for a user text message.
+func userTextEntry(timestamp string, text string) string {
+	return jsonlLine(map[string]interface{}{
+		"type":      "user",
+		"timestamp": timestamp,
+		"sessionId": "test-session",
+		"message": map[string]interface{}{
+			"role": "user",
+			"content": []map[string]interface{}{
+				{"type": "text", "text": text},
+			},
+		},
+	})
 }
 
-// fixtureToolCallSession returns a session where the assistant invokes a Bash
-// tool and the user entry carries the tool_result.
-func fixtureToolCallSession() []string {
-	return []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"tool1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_1","name":"Bash","input":{"command":"ls -la","description":"list files"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, 3*time.Second) + `","sessionId":"tool1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_1","content":"total 42\ndrwxr-xr-x 3 user user 4096 Feb 19 10:00 ."}]}}`,
-	}
+// assistantTextEntry creates a JSONL line for an assistant text message.
+func assistantTextEntry(timestamp string, text string) string {
+	return jsonlLine(map[string]interface{}{
+		"type":      "assistant",
+		"timestamp": timestamp,
+		"sessionId": "test-session",
+		"message": map[string]interface{}{
+			"role": "assistant",
+			"content": []map[string]interface{}{
+				{"type": "text", "text": text},
+			},
+		},
+	})
 }
 
-// fixtureAllToolTypes returns lines exercising every supported tool type.
-func fixtureAllToolTypes() []string {
-	tools := []struct {
-		id, name string
-		input    string
-	}{
-		{"tu_bash", "Bash", `{"command":"echo ok","description":"test echo"}`},
-		{"tu_read", "Read", `{"file_path":"/tmp/foo.go","offset":0,"limit":100}`},
-		{"tu_edit", "Edit", `{"file_path":"/tmp/foo.go","old_string":"old","new_string":"new"}`},
-		{"tu_write", "Write", `{"file_path":"/tmp/bar.go","content":"package bar"}`},
-		{"tu_grep", "Grep", `{"pattern":"TODO","path":"/src"}`},
-		{"tu_glob", "Glob", `{"pattern":"**/*.go","path":"/src"}`},
-		{"tu_task", "Task", `{"prompt":"summarise","description":"summarise code","subagent_type":"research"}`},
-	}
-
-	var lines []string
-	for i, tool := range tools {
-		off := time.Duration(i*2) * time.Second
-		// Assistant makes the tool_use call.
-		lines = append(lines, `{"type":"assistant","timestamp":"`+ts(baseTime, off)+`","sessionId":"all_tools","message":{"role":"assistant","content":[{"type":"tool_use","id":"`+tool.id+`","name":"`+tool.name+`","input":`+tool.input+`}]}}`)
-		// User entry carries the tool_result.
-		lines = append(lines, `{"type":"user","timestamp":"`+ts(baseTime, off+time.Second)+`","sessionId":"all_tools","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"`+tool.id+`","content":"result ok"}]}}`)
-	}
-	return lines
+// toolUseEntry creates a JSONL line for an assistant message containing a tool_use block.
+func toolUseEntry(timestamp, toolName, toolID string, input map[string]interface{}) string {
+	return jsonlLine(map[string]interface{}{
+		"type":      "assistant",
+		"timestamp": timestamp,
+		"sessionId": "test-session",
+		"message": map[string]interface{}{
+			"role": "assistant",
+			"content": []map[string]interface{}{
+				{
+					"type":  "tool_use",
+					"name":  toolName,
+					"id":    toolID,
+					"input": input,
+				},
+			},
+		},
+	})
 }
 
-// fixtureErrorToolResult returns a session with a failing tool call.
-func fixtureErrorToolResult() []string {
-	return []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"err1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_err","name":"Bash","input":{"command":"bad-cmd"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"err1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_err","is_error":true,"content":"command not found: bad-cmd"}]}}`,
+// toolResultEntry creates a JSONL line for a user message containing a tool_result block.
+func toolResultEntry(timestamp, toolUseID string, content interface{}, isError bool) string {
+	entry := map[string]interface{}{
+		"type":      "user",
+		"timestamp": timestamp,
+		"sessionId": "test-session",
+		"message": map[string]interface{}{
+			"role": "user",
+			"content": []map[string]interface{}{
+				{
+					"type":        "tool_result",
+					"tool_use_id": toolUseID,
+					"content":     content,
+					"is_error":    isError,
+				},
+			},
+		},
 	}
+	return jsonlLine(entry)
 }
 
-// -- ParseTranscript tests --
+// writeJSONL writes lines to a temp .jsonl file and returns its path.
+func writeJSONL(t *testing.T, dir string, name string, lines ...string) string {
+	t.Helper()
+	path := filepath.Join(dir, name)
+	err := os.WriteFile(path, []byte(strings.Join(lines, "\n")+"\n"), 0644)
+	require.NoError(t, err)
+	return path
+}
 
-func TestParseTranscript_MinimalValid(t *testing.T) {
+// --- ParseTranscript tests ---
+
+func TestParseTranscript_MinimalValid_Good(t *testing.T) {
 	dir := t.TempDir()
-	path := writeTempJSONL(t, dir, "minimal.jsonl", fixtureMinimalSession()...)
+	path := writeJSONL(t, dir, "minimal.jsonl",
+		userTextEntry(ts(0), "Hello"),
+		assistantTextEntry(ts(1), "Hi there!"),
+	)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
+	require.NotNil(t, sess)
 
 	assert.Equal(t, "minimal", sess.ID)
 	assert.Equal(t, path, sess.Path)
 	assert.False(t, sess.StartTime.IsZero(), "StartTime should be set")
 	assert.False(t, sess.EndTime.IsZero(), "EndTime should be set")
-	assert.True(t, sess.EndTime.After(sess.StartTime), "EndTime should be after StartTime")
+	assert.True(t, sess.EndTime.After(sess.StartTime) || sess.EndTime.Equal(sess.StartTime))
 
+	// Should have a user event and an assistant event
 	require.Len(t, sess.Events, 2)
-
-	// First event: user message
 	assert.Equal(t, "user", sess.Events[0].Type)
-	assert.Equal(t, "hello", sess.Events[0].Input)
-
-	// Second event: assistant message
+	assert.Equal(t, "Hello", sess.Events[0].Input)
 	assert.Equal(t, "assistant", sess.Events[1].Type)
-	assert.Equal(t, "Hi there.", sess.Events[1].Input)
+	assert.Equal(t, "Hi there!", sess.Events[1].Input)
 }
 
-func TestParseTranscript_ToolCallBash(t *testing.T) {
+func TestParseTranscript_ToolCalls_Good(t *testing.T) {
 	dir := t.TempDir()
-	path := writeTempJSONL(t, dir, "toolcall.jsonl", fixtureToolCallSession()...)
+
+	lines := []string{
+		userTextEntry(ts(0), "Run a command"),
+		// Bash tool_use
+		toolUseEntry(ts(1), "Bash", "tool-bash-1", map[string]interface{}{
+			"command":     "ls -la",
+			"description": "list files",
+		}),
+		toolResultEntry(ts(2), "tool-bash-1", "total 42\ndrwxr-xr-x 5 user staff 160 Feb 20 10:00 .", false),
+		// Read tool_use
+		toolUseEntry(ts(3), "Read", "tool-read-1", map[string]interface{}{
+			"file_path": "/tmp/test.go",
+		}),
+		toolResultEntry(ts(4), "tool-read-1", "package main\n\nfunc main() {}", false),
+		// Edit tool_use
+		toolUseEntry(ts(5), "Edit", "tool-edit-1", map[string]interface{}{
+			"file_path":  "/tmp/test.go",
+			"old_string": "main",
+			"new_string": "app",
+		}),
+		toolResultEntry(ts(6), "tool-edit-1", "ok", false),
+		// Write tool_use
+		toolUseEntry(ts(7), "Write", "tool-write-1", map[string]interface{}{
+			"file_path": "/tmp/new.go",
+			"content":   "package new\n",
+		}),
+		toolResultEntry(ts(8), "tool-write-1", "ok", false),
+		// Grep tool_use
+		toolUseEntry(ts(9), "Grep", "tool-grep-1", map[string]interface{}{
+			"pattern": "TODO",
+			"path":    "/tmp",
+		}),
+		toolResultEntry(ts(10), "tool-grep-1", "/tmp/test.go:3:// TODO fix this", false),
+		// Glob tool_use
+		toolUseEntry(ts(11), "Glob", "tool-glob-1", map[string]interface{}{
+			"pattern": "**/*.go",
+		}),
+		toolResultEntry(ts(12), "tool-glob-1", "/tmp/test.go\n/tmp/new.go", false),
+		// Task tool_use
+		toolUseEntry(ts(13), "Task", "tool-task-1", map[string]interface{}{
+			"prompt":       "Analyse the code",
+			"description":  "Code analysis",
+			"subagent_type": "research",
+		}),
+		toolResultEntry(ts(14), "tool-task-1", "Analysis complete", false),
+		assistantTextEntry(ts(15), "All done."),
+	}
+
+	path := writeJSONL(t, dir, "tools.jsonl", lines...)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
 
-	// Should have one tool_use event (the assistant text block is empty,
-	// so only the completed tool call appears).
-	require.Len(t, sess.Events, 1)
-	evt := sess.Events[0]
-
-	assert.Equal(t, "tool_use", evt.Type)
-	assert.Equal(t, "Bash", evt.Tool)
-	assert.Equal(t, "tu_1", evt.ToolID)
-	assert.Contains(t, evt.Input, "ls -la")
-	assert.Contains(t, evt.Input, "# list files")
-	assert.Contains(t, evt.Output, "total 42")
-	assert.True(t, evt.Success)
-	assert.Equal(t, 3*time.Second, evt.Duration)
-}
-
-func TestParseTranscript_AllToolTypes(t *testing.T) {
-	dir := t.TempDir()
-	path := writeTempJSONL(t, dir, "alltools.jsonl", fixtureAllToolTypes()...)
-
-	sess, err := ParseTranscript(path)
-	require.NoError(t, err)
-
-	expectedTools := []string{"Bash", "Read", "Edit", "Write", "Grep", "Glob", "Task"}
-	var gotTools []string
-	for _, evt := range sess.Events {
-		if evt.Type == "tool_use" {
-			gotTools = append(gotTools, evt.Tool)
+	// Count tool_use events
+	var toolEvents []Event
+	for _, e := range sess.Events {
+		if e.Type == "tool_use" {
+			toolEvents = append(toolEvents, e)
 		}
 	}
-	assert.Equal(t, expectedTools, gotTools)
+
+	require.Len(t, toolEvents, 7, "should have 7 tool_use events")
+
+	// Verify each tool was parsed correctly
+	assert.Equal(t, "Bash", toolEvents[0].Tool)
+	assert.Contains(t, toolEvents[0].Input, "ls -la")
+	assert.Contains(t, toolEvents[0].Input, "# list files")
+	assert.True(t, toolEvents[0].Success)
+	assert.Equal(t, time.Second, toolEvents[0].Duration)
+
+	assert.Equal(t, "Read", toolEvents[1].Tool)
+	assert.Equal(t, "/tmp/test.go", toolEvents[1].Input)
+
+	assert.Equal(t, "Edit", toolEvents[2].Tool)
+	assert.Equal(t, "/tmp/test.go (edit)", toolEvents[2].Input)
+
+	assert.Equal(t, "Write", toolEvents[3].Tool)
+	assert.Equal(t, "/tmp/new.go (12 bytes)", toolEvents[3].Input)
+
+	assert.Equal(t, "Grep", toolEvents[4].Tool)
+	assert.Equal(t, "/TODO/ in /tmp", toolEvents[4].Input)
+
+	assert.Equal(t, "Glob", toolEvents[5].Tool)
+	assert.Equal(t, "**/*.go", toolEvents[5].Input)
+
+	assert.Equal(t, "Task", toolEvents[6].Tool)
+	assert.Equal(t, "[research] Code analysis", toolEvents[6].Input)
 }
 
-func TestParseTranscript_ErrorToolResult(t *testing.T) {
+func TestParseTranscript_ToolError_Good(t *testing.T) {
 	dir := t.TempDir()
-	path := writeTempJSONL(t, dir, "error.jsonl", fixtureErrorToolResult()...)
+	path := writeJSONL(t, dir, "error.jsonl",
+		toolUseEntry(ts(0), "Bash", "tool-err-1", map[string]interface{}{
+			"command": "cat /nonexistent",
+		}),
+		toolResultEntry(ts(1), "tool-err-1", "cat: /nonexistent: No such file or directory", true),
+	)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
 
-	require.Len(t, sess.Events, 1)
-	evt := sess.Events[0]
-	assert.False(t, evt.Success)
-	assert.Contains(t, evt.ErrorMsg, "command not found")
+	var toolEvents []Event
+	for _, e := range sess.Events {
+		if e.Type == "tool_use" {
+			toolEvents = append(toolEvents, e)
+		}
+	}
+
+	require.Len(t, toolEvents, 1)
+	assert.False(t, toolEvents[0].Success)
+	assert.Contains(t, toolEvents[0].ErrorMsg, "No such file or directory")
 }
 
-func TestParseTranscript_EmptyFile(t *testing.T) {
+func TestParseTranscript_EmptyFile_Bad(t *testing.T) {
 	dir := t.TempDir()
-	path := writeTempJSONL(t, dir, "empty.jsonl")
+	path := writeJSONL(t, dir, "empty.jsonl")
+	// Write a truly empty file
+	require.NoError(t, os.WriteFile(path, []byte(""), 0644))
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
+	require.NotNil(t, sess)
 	assert.Empty(t, sess.Events)
 	assert.True(t, sess.StartTime.IsZero())
 }
 
-func TestParseTranscript_MalformedLines(t *testing.T) {
+func TestParseTranscript_MalformedJSON_Bad(t *testing.T) {
 	dir := t.TempDir()
-	lines := []string{
-		`{not valid json`,
-		`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"x","message":{"role":"user","content":[{"type":"text","text":"ok"}]}}`,
-		`{also bad`,
-		`{"type":"assistant","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"x","message":{"role":"assistant","content":[{"type":"text","text":"reply"}]}}`,
-	}
-	path := writeTempJSONL(t, dir, "malformed.jsonl", lines...)
+	path := writeJSONL(t, dir, "malformed.jsonl",
+		`{invalid json`,
+		`{"type": "user", "timestamp": "`+ts(0)+`", not valid`,
+		userTextEntry(ts(1), "This line is valid"),
+		`}}}`,
+		assistantTextEntry(ts(2), "This is also valid"),
+	)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err, "malformed lines should be skipped, not cause an error")
-	assert.Len(t, sess.Events, 2, "only the two valid lines should produce events")
+	require.NotNil(t, sess)
+
+	// Only the valid lines should produce events
+	assert.Len(t, sess.Events, 2)
+	assert.Equal(t, "user", sess.Events[0].Type)
+	assert.Equal(t, "assistant", sess.Events[1].Type)
 }
 
-func TestParseTranscript_TruncatedInput(t *testing.T) {
+func TestParseTranscript_TruncatedJSONL_Bad(t *testing.T) {
 	dir := t.TempDir()
-	// Final line is incomplete JSON (no closing brace).
-	lines := []string{
-		`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"trunc","message":{"role":"user","content":[{"type":"text","text":"start"}]}}`,
-		`{"type":"assistant","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"trunc","message":{"role":"assistant","content":[{"type":"text","text":"partial`,
+	validLine := userTextEntry(ts(0), "Hello")
+	// Truncated line: cut a valid JSON line in half
+	truncated := assistantTextEntry(ts(1), "World")
+	truncated = truncated[:len(truncated)/2]
+
+	path := writeJSONL(t, dir, "truncated.jsonl", validLine, truncated)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err, "truncated last line should be skipped gracefully")
+	require.NotNil(t, sess)
+
+	// Only the first valid line should produce an event
+	assert.Len(t, sess.Events, 1)
+	assert.Equal(t, "user", sess.Events[0].Type)
+}
+
+func TestParseTranscript_LargeSession_Good(t *testing.T) {
+	dir := t.TempDir()
+
+	var lines []string
+	lines = append(lines, userTextEntry(ts(0), "Start large session"))
+
+	// Generate 1000+ tool call pairs
+	for i := 0; i < 1100; i++ {
+		toolID := fmt.Sprintf("tool-%d", i)
+		offset := (i * 2) + 1
+		lines = append(lines,
+			toolUseEntry(ts(offset), "Bash", toolID, map[string]interface{}{
+				"command": fmt.Sprintf("echo %d", i),
+			}),
+			toolResultEntry(ts(offset+1), toolID, fmt.Sprintf("output %d", i), false),
+		)
 	}
-	path := writeTempJSONL(t, dir, "truncated.jsonl", lines...)
+	lines = append(lines, assistantTextEntry(ts(2202), "Done"))
+
+	path := writeJSONL(t, dir, "large.jsonl", lines...)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
-	// Only the first valid line should produce an event.
-	assert.Len(t, sess.Events, 1)
-	assert.Equal(t, "start", sess.Events[0].Input)
+
+	var toolCount int
+	for _, e := range sess.Events {
+		if e.Type == "tool_use" {
+			toolCount++
+		}
+	}
+	assert.Equal(t, 1100, toolCount, "all 1100 tool events should be parsed")
 }
 
-func TestParseTranscript_FileNotFound(t *testing.T) {
-	_, err := ParseTranscript("/nonexistent/path.jsonl")
+func TestParseTranscript_NestedToolResults_Good(t *testing.T) {
+	dir := t.TempDir()
+
+	// Tool result with array content (multiple text blocks)
+	arrayContent := []map[string]interface{}{
+		{"type": "text", "text": "First block"},
+		{"type": "text", "text": "Second block"},
+	}
+
+	lines := []string{
+		toolUseEntry(ts(0), "Bash", "tool-nested-1", map[string]interface{}{
+			"command": "complex output",
+		}),
+		// Build the tool result with array content manually
+		jsonlLine(map[string]interface{}{
+			"type":      "user",
+			"timestamp": ts(1),
+			"sessionId": "test-session",
+			"message": map[string]interface{}{
+				"role": "user",
+				"content": []map[string]interface{}{
+					{
+						"type":        "tool_result",
+						"tool_use_id": "tool-nested-1",
+						"content":     arrayContent,
+						"is_error":    false,
+					},
+				},
+			},
+		}),
+	}
+
+	path := writeJSONL(t, dir, "nested.jsonl", lines...)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err)
+
+	var toolEvents []Event
+	for _, e := range sess.Events {
+		if e.Type == "tool_use" {
+			toolEvents = append(toolEvents, e)
+		}
+	}
+
+	require.Len(t, toolEvents, 1)
+	assert.Contains(t, toolEvents[0].Output, "First block")
+	assert.Contains(t, toolEvents[0].Output, "Second block")
+}
+
+func TestParseTranscript_NestedMapResult_Good(t *testing.T) {
+	dir := t.TempDir()
+
+	lines := []string{
+		toolUseEntry(ts(0), "Read", "tool-map-1", map[string]interface{}{
+			"file_path": "/tmp/data.json",
+		}),
+		// Build a tool result with map content
+		jsonlLine(map[string]interface{}{
+			"type":      "user",
+			"timestamp": ts(1),
+			"sessionId": "test-session",
+			"message": map[string]interface{}{
+				"role": "user",
+				"content": []map[string]interface{}{
+					{
+						"type":        "tool_result",
+						"tool_use_id": "tool-map-1",
+						"content": map[string]interface{}{
+							"text": "file contents here",
+						},
+						"is_error": false,
+					},
+				},
+			},
+		}),
+	}
+
+	path := writeJSONL(t, dir, "map-result.jsonl", lines...)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err)
+
+	var toolEvents []Event
+	for _, e := range sess.Events {
+		if e.Type == "tool_use" {
+			toolEvents = append(toolEvents, e)
+		}
+	}
+
+	require.Len(t, toolEvents, 1)
+	assert.Contains(t, toolEvents[0].Output, "file contents here")
+}
+
+func TestParseTranscript_FileNotFound_Ugly(t *testing.T) {
+	_, err := ParseTranscript("/nonexistent/path/session.jsonl")
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "open transcript")
 }
 
-func TestParseTranscript_LargeSession(t *testing.T) {
+func TestParseTranscript_SessionIDFromFilename_Good(t *testing.T) {
 	dir := t.TempDir()
-	var lines []string
-	// Generate 500 user+assistant pairs = 1000 lines.
-	for i := 0; i < 500; i++ {
-		off := time.Duration(i*2) * time.Second
-		lines = append(lines,
-			`{"type":"user","timestamp":"`+ts(baseTime, off)+`","sessionId":"large","message":{"role":"user","content":[{"type":"text","text":"msg `+strings.Repeat("x", 50)+`"}]}}`,
-			`{"type":"assistant","timestamp":"`+ts(baseTime, off+time.Second)+`","sessionId":"large","message":{"role":"assistant","content":[{"type":"text","text":"reply `+strings.Repeat("y", 50)+`"}]}}`,
-		)
-	}
-	path := writeTempJSONL(t, dir, "large.jsonl", lines...)
+	path := writeJSONL(t, dir, "abc123def456.jsonl",
+		userTextEntry(ts(0), "test"),
+	)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
-	assert.Len(t, sess.Events, 1000)
+	assert.Equal(t, "abc123def456", sess.ID)
 }
 
-func TestParseTranscript_ToolResultArrayContent(t *testing.T) {
-	// tool_result whose content is an array of text blocks.
+func TestParseTranscript_TimestampsTracked_Good(t *testing.T) {
 	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"arr","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_arr","name":"Bash","input":{"command":"echo hi"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"arr","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_arr","content":[{"type":"text","text":"line1"},{"type":"text","text":"line2"}]}]}}`,
-	}
-	path := writeTempJSONL(t, dir, "array_content.jsonl", lines...)
+	path := writeJSONL(t, dir, "timestamps.jsonl",
+		userTextEntry(ts(0), "start"),
+		assistantTextEntry(ts(5), "middle"),
+		userTextEntry(ts(10), "end"),
+	)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
+
+	expectedStart, _ := time.Parse(time.RFC3339Nano, ts(0))
+	expectedEnd, _ := time.Parse(time.RFC3339Nano, ts(10))
+
+	assert.Equal(t, expectedStart, sess.StartTime)
+	assert.Equal(t, expectedEnd, sess.EndTime)
+}
+
+func TestParseTranscript_TextTruncation_Good(t *testing.T) {
+	dir := t.TempDir()
+	longText := strings.Repeat("x", 600)
+	path := writeJSONL(t, dir, "truncation.jsonl",
+		userTextEntry(ts(0), longText),
+	)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err)
+
 	require.Len(t, sess.Events, 1)
-	assert.Contains(t, sess.Events[0].Output, "line1")
-	assert.Contains(t, sess.Events[0].Output, "line2")
+	// Input should be truncated to 500 + "..."
+	assert.True(t, len(sess.Events[0].Input) <= 504, "input should be truncated")
+	assert.True(t, strings.HasSuffix(sess.Events[0].Input, "..."), "truncated text should end with ...")
 }
 
-func TestParseTranscript_ToolResultMapContent(t *testing.T) {
-	// tool_result whose content is a map with a text key.
+func TestParseTranscript_MixedContentBlocks_Good(t *testing.T) {
+	// Assistant message with both text and tool_use in the same message
 	dir := t.TempDir()
+
 	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"map","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_map","name":"Read","input":{"file_path":"/tmp/x"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"map","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_map","content":{"text":"file contents here"}}]}}`,
+		// An assistant message with text + tool_use in the same content array
+		jsonlLine(map[string]interface{}{
+			"type":      "assistant",
+			"timestamp": ts(0),
+			"sessionId": "test-session",
+			"message": map[string]interface{}{
+				"role": "assistant",
+				"content": []map[string]interface{}{
+					{"type": "text", "text": "Let me check that file."},
+					{
+						"type":  "tool_use",
+						"name":  "Read",
+						"id":    "tool-mixed-1",
+						"input": map[string]interface{}{"file_path": "/tmp/mix.go"},
+					},
+				},
+			},
+		}),
+		toolResultEntry(ts(1), "tool-mixed-1", "package mix", false),
 	}
-	path := writeTempJSONL(t, dir, "map_content.jsonl", lines...)
+
+	path := writeJSONL(t, dir, "mixed.jsonl", lines...)
 
 	sess, err := ParseTranscript(path)
 	require.NoError(t, err)
-	require.Len(t, sess.Events, 1)
-	assert.Equal(t, "file contents here", sess.Events[0].Output)
-}
 
-func TestParseTranscript_UnmatchedToolResult(t *testing.T) {
-	// A tool_result whose tool_use_id doesn't match any pending tool_use.
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"unmatched","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"nonexistent","content":"orphan result"}]}}`,
-	}
-	path := writeTempJSONL(t, dir, "unmatched.jsonl", lines...)
-
-	sess, err := ParseTranscript(path)
-	require.NoError(t, err)
-	// Unmatched tool_result should be silently ignored.
-	assert.Empty(t, sess.Events)
-}
-
-func TestParseTranscript_MixedContentBlocks(t *testing.T) {
-	// An assistant message with both text and tool_use blocks.
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"mixed","message":{"role":"assistant","content":[{"type":"text","text":"I will read the file."},{"type":"tool_use","id":"tu_mix","name":"Read","input":{"file_path":"/etc/hosts"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"mixed","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_mix","content":"127.0.0.1 localhost"}]}}`,
-	}
-	path := writeTempJSONL(t, dir, "mixed.jsonl", lines...)
-
-	sess, err := ParseTranscript(path)
-	require.NoError(t, err)
-	// Should get: 1 assistant text + 1 tool_use
+	// Should have an assistant text event + a tool_use event
 	require.Len(t, sess.Events, 2)
 	assert.Equal(t, "assistant", sess.Events[0].Type)
-	assert.Equal(t, "I will read the file.", sess.Events[0].Input)
 	assert.Equal(t, "tool_use", sess.Events[1].Type)
 	assert.Equal(t, "Read", sess.Events[1].Tool)
 }
 
-// -- extractToolInput tests --
-
-func TestExtractToolInput(t *testing.T) {
-	tests := []struct {
-		name     string
-		toolName string
-		input    string
-		want     string
-	}{
-		{
-			name:     "Bash with description",
-			toolName: "Bash",
-			input:    `{"command":"ls -la","description":"list files"}`,
-			want:     "ls -la # list files",
-		},
-		{
-			name:     "Bash without description",
-			toolName: "Bash",
-			input:    `{"command":"pwd"}`,
-			want:     "pwd",
-		},
-		{
-			name:     "Read",
-			toolName: "Read",
-			input:    `{"file_path":"/home/user/main.go","offset":10,"limit":50}`,
-			want:     "/home/user/main.go",
-		},
-		{
-			name:     "Edit",
-			toolName: "Edit",
-			input:    `{"file_path":"/tmp/test.go","old_string":"foo","new_string":"bar"}`,
-			want:     "/tmp/test.go (edit)",
-		},
-		{
-			name:     "Write",
-			toolName: "Write",
-			input:    `{"file_path":"/tmp/out.txt","content":"hello world"}`,
-			want:     "/tmp/out.txt (11 bytes)",
-		},
-		{
-			name:     "Grep with path",
-			toolName: "Grep",
-			input:    `{"pattern":"TODO","path":"/src"}`,
-			want:     "/TODO/ in /src",
-		},
-		{
-			name:     "Grep without path",
-			toolName: "Grep",
-			input:    `{"pattern":"FIXME"}`,
-			want:     "/FIXME/ in .",
-		},
-		{
-			name:     "Glob",
-			toolName: "Glob",
-			input:    `{"pattern":"**/*.go","path":"/src"}`,
-			want:     "**/*.go",
-		},
-		{
-			name:     "Task with description",
-			toolName: "Task",
-			input:    `{"prompt":"do something long","description":"short desc","subagent_type":"research"}`,
-			want:     "[research] short desc",
-		},
-		{
-			name:     "Task without description falls back to prompt",
-			toolName: "Task",
-			input:    `{"prompt":"analyse this code","subagent_type":"codegen"}`,
-			want:     "[codegen] analyse this code",
-		},
-		{
-			name:     "Unknown tool shows sorted keys",
-			toolName: "CustomMCP",
-			input:    `{"beta":"b","alpha":"a"}`,
-			want:     "alpha, beta",
-		},
-		{
-			name:     "Nil input",
-			toolName: "Bash",
-			input:    "",
-			want:     "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var raw json.RawMessage
-			if tt.input != "" {
-				raw = json.RawMessage(tt.input)
-			}
-			got := extractToolInput(tt.toolName, raw)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-// -- extractResultContent tests --
-
-func TestExtractResultContent(t *testing.T) {
-	tests := []struct {
-		name    string
-		content interface{}
-		want    string
-	}{
-		{
-			name:    "string content",
-			content: "simple output",
-			want:    "simple output",
-		},
-		{
-			name: "array of text blocks",
-			content: []interface{}{
-				map[string]interface{}{"type": "text", "text": "line1"},
-				map[string]interface{}{"type": "text", "text": "line2"},
-			},
-			want: "line1\nline2",
-		},
-		{
-			name:    "map with text key",
-			content: map[string]interface{}{"text": "map value"},
-			want:    "map value",
-		},
-		{
-			name:    "map without text key",
-			content: map[string]interface{}{"data": 42},
-			want:    "map[data:42]",
-		},
-		{
-			name:    "nil content",
-			content: nil,
-			want:    "<nil>",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractResultContent(tt.content)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-// -- truncate tests --
-
-func TestTruncate(t *testing.T) {
-	tests := []struct {
-		name string
-		s    string
-		max  int
-		want string
-	}{
-		{"short string", "hello", 10, "hello"},
-		{"exact length", "hello", 5, "hello"},
-		{"truncated", "hello world", 5, "hello..."},
-		{"empty string", "", 10, ""},
-		{"zero max", "hello", 0, "..."},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, truncate(tt.s, tt.max))
-		})
-	}
-}
-
-// -- ListSessions tests --
-
-func TestListSessions_EmptyDir(t *testing.T) {
+func TestParseTranscript_UnmatchedToolResult_Bad(t *testing.T) {
+	// A tool_result with no matching tool_use should be silently ignored
 	dir := t.TempDir()
+	path := writeJSONL(t, dir, "unmatched.jsonl",
+		toolResultEntry(ts(0), "nonexistent-tool-id", "orphan result", false),
+		userTextEntry(ts(1), "Normal message"),
+	)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err)
+
+	// Only the user text event should appear; the orphan tool result is ignored
+	require.Len(t, sess.Events, 1)
+	assert.Equal(t, "user", sess.Events[0].Type)
+}
+
+func TestParseTranscript_EmptyTimestamp_Bad(t *testing.T) {
+	dir := t.TempDir()
+	// Entry with empty timestamp
+	line := jsonlLine(map[string]interface{}{
+		"type":      "user",
+		"timestamp": "",
+		"sessionId": "test-session",
+		"message": map[string]interface{}{
+			"role": "user",
+			"content": []map[string]interface{}{
+				{"type": "text", "text": "No timestamp"},
+			},
+		},
+	})
+	path := writeJSONL(t, dir, "no-ts.jsonl", line)
+
+	sess, err := ParseTranscript(path)
+	require.NoError(t, err)
+
+	// The event should still be parsed, but StartTime remains zero
+	assert.True(t, sess.StartTime.IsZero())
+}
+
+// --- ListSessions tests ---
+
+func TestListSessions_EmptyDir_Good(t *testing.T) {
+	dir := t.TempDir()
+
 	sessions, err := ListSessions(dir)
 	require.NoError(t, err)
 	assert.Empty(t, sessions)
 }
 
-func TestListSessions_SingleSession(t *testing.T) {
+func TestListSessions_SingleSession_Good(t *testing.T) {
 	dir := t.TempDir()
-	writeTempJSONL(t, dir, "sess-001.jsonl", fixtureMinimalSession()...)
+	writeJSONL(t, dir, "session-abc.jsonl",
+		userTextEntry(ts(0), "Hello"),
+		assistantTextEntry(ts(5), "World"),
+	)
 
 	sessions, err := ListSessions(dir)
 	require.NoError(t, err)
 	require.Len(t, sessions, 1)
-	assert.Equal(t, "sess-001", sessions[0].ID)
+
+	assert.Equal(t, "session-abc", sessions[0].ID)
 	assert.False(t, sessions[0].StartTime.IsZero())
 	assert.False(t, sessions[0].EndTime.IsZero())
 }
 
-func TestListSessions_MultipleSorted(t *testing.T) {
+func TestListSessions_MultipleSorted_Good(t *testing.T) {
 	dir := t.TempDir()
 
-	// Create sessions with different timestamps.
-	early := time.Date(2026, 1, 1, 10, 0, 0, 0, time.UTC)
-	late := time.Date(2026, 2, 1, 10, 0, 0, 0, time.UTC)
-
-	earlyLines := []string{
-		`{"type":"user","timestamp":"` + early.Format(time.RFC3339Nano) + `","sessionId":"early","message":{"role":"user","content":[{"type":"text","text":"old"}]}}`,
-	}
-	lateLines := []string{
-		`{"type":"user","timestamp":"` + late.Format(time.RFC3339Nano) + `","sessionId":"late","message":{"role":"user","content":[{"type":"text","text":"new"}]}}`,
-	}
-
-	writeTempJSONL(t, dir, "early.jsonl", earlyLines...)
-	writeTempJSONL(t, dir, "late.jsonl", lateLines...)
+	// Create three sessions with different timestamps.
+	// Session "old" starts at ts(0), "mid" at ts(100), "new" at ts(200).
+	writeJSONL(t, dir, "old.jsonl",
+		userTextEntry(ts(0), "old session"),
+	)
+	writeJSONL(t, dir, "mid.jsonl",
+		userTextEntry(ts(100), "mid session"),
+	)
+	writeJSONL(t, dir, "new.jsonl",
+		userTextEntry(ts(200), "new session"),
+	)
 
 	sessions, err := ListSessions(dir)
 	require.NoError(t, err)
-	require.Len(t, sessions, 2)
-	// Should be sorted newest first.
-	assert.Equal(t, "late", sessions[0].ID)
-	assert.Equal(t, "early", sessions[1].ID)
+	require.Len(t, sessions, 3)
+
+	// Should be sorted newest first
+	assert.Equal(t, "new", sessions[0].ID)
+	assert.Equal(t, "mid", sessions[1].ID)
+	assert.Equal(t, "old", sessions[2].ID)
 }
 
-func TestListSessions_IgnoresNonJSONL(t *testing.T) {
+func TestListSessions_NonJSONLIgnored_Good(t *testing.T) {
 	dir := t.TempDir()
-	writeTempJSONL(t, dir, "session.jsonl", fixtureMinimalSession()...)
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("not a session"), 0644))
+
+	writeJSONL(t, dir, "real-session.jsonl",
+		userTextEntry(ts(0), "real"),
+	)
+	// Write non-JSONL files
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "readme.md"), []byte("# Hello"), 0644))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("notes"), 0644))
 	require.NoError(t, os.WriteFile(filepath.Join(dir, "data.json"), []byte("{}"), 0644))
 
 	sessions, err := ListSessions(dir)
 	require.NoError(t, err)
-	assert.Len(t, sessions, 1)
+	require.Len(t, sessions, 1)
+	assert.Equal(t, "real-session", sessions[0].ID)
 }
 
-func TestListSessions_MalformedContent(t *testing.T) {
+func TestListSessions_MalformedJSONLStillListed_Bad(t *testing.T) {
 	dir := t.TempDir()
-	// A .jsonl file with no valid timestamps at all — should still appear
-	// with a fallback start time from file mod time.
-	writeTempJSONL(t, dir, "bad.jsonl", `{not json}`, `{also bad}`)
+
+	// A .jsonl file with no valid timestamps — should still list with zero time or modtime
+	writeJSONL(t, dir, "broken.jsonl",
+		`{invalid json}`,
+		`also not valid`,
+	)
 
 	sessions, err := ListSessions(dir)
 	require.NoError(t, err)
 	require.Len(t, sessions, 1)
-	// StartTime should fall back to the file's mod time.
-	assert.False(t, sessions[0].StartTime.IsZero())
+	assert.Equal(t, "broken", sessions[0].ID)
+	// StartTime should fall back to file modtime since no valid timestamps
+	assert.False(t, sessions[0].StartTime.IsZero(), "should fall back to file modtime")
 }
 
-// -- Benchmark --
+// --- extractToolInput tests ---
 
-func BenchmarkParseTranscript(b *testing.B) {
-	dir := b.TempDir()
-	var lines []string
-	for i := 0; i < 2000; i++ {
-		off := time.Duration(i*2) * time.Second
-		lines = append(lines,
-			`{"type":"assistant","timestamp":"`+ts(baseTime, off)+`","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_`+strings.Repeat("a", 5)+`_`+string(rune('0'+i%10))+`","name":"Bash","input":{"command":"echo hello"}}]}}`,
-			`{"type":"user","timestamp":"`+ts(baseTime, off+time.Second)+`","sessionId":"bench","message":{"role":"user","content":[{"type":"text","text":"msg"}]}}`,
-		)
-	}
-	path := writeTempJSONL(&testing.T{}, dir, "bench.jsonl", lines...)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = ParseTranscript(path)
-	}
+func TestExtractToolInput_Bash_Good(t *testing.T) {
+	input := json.RawMessage(`{"command":"go test ./...","description":"run tests","timeout":120}`)
+	result := extractToolInput("Bash", input)
+	assert.Equal(t, "go test ./... # run tests", result)
+}
+
+func TestExtractToolInput_BashNoDescription_Good(t *testing.T) {
+	input := json.RawMessage(`{"command":"ls -la"}`)
+	result := extractToolInput("Bash", input)
+	assert.Equal(t, "ls -la", result)
+}
+
+func TestExtractToolInput_Read_Good(t *testing.T) {
+	input := json.RawMessage(`{"file_path":"/Users/test/main.go","offset":10,"limit":50}`)
+	result := extractToolInput("Read", input)
+	assert.Equal(t, "/Users/test/main.go", result)
+}
+
+func TestExtractToolInput_Edit_Good(t *testing.T) {
+	input := json.RawMessage(`{"file_path":"/tmp/app.go","old_string":"foo","new_string":"bar"}`)
+	result := extractToolInput("Edit", input)
+	assert.Equal(t, "/tmp/app.go (edit)", result)
+}
+
+func TestExtractToolInput_Write_Good(t *testing.T) {
+	input := json.RawMessage(`{"file_path":"/tmp/out.txt","content":"hello world"}`)
+	result := extractToolInput("Write", input)
+	assert.Equal(t, "/tmp/out.txt (11 bytes)", result)
+}
+
+func TestExtractToolInput_Grep_Good(t *testing.T) {
+	input := json.RawMessage(`{"pattern":"TODO","path":"/src"}`)
+	result := extractToolInput("Grep", input)
+	assert.Equal(t, "/TODO/ in /src", result)
+}
+
+func TestExtractToolInput_GrepNoPath_Good(t *testing.T) {
+	input := json.RawMessage(`{"pattern":"FIXME"}`)
+	result := extractToolInput("Grep", input)
+	assert.Equal(t, "/FIXME/ in .", result)
+}
+
+func TestExtractToolInput_Glob_Good(t *testing.T) {
+	input := json.RawMessage(`{"pattern":"**/*.go","path":"/src"}`)
+	result := extractToolInput("Glob", input)
+	assert.Equal(t, "**/*.go", result)
+}
+
+func TestExtractToolInput_Task_Good(t *testing.T) {
+	input := json.RawMessage(`{"prompt":"Analyse the codebase","description":"Code review","subagent_type":"research"}`)
+	result := extractToolInput("Task", input)
+	assert.Equal(t, "[research] Code review", result)
+}
+
+func TestExtractToolInput_TaskNoDescription_Good(t *testing.T) {
+	input := json.RawMessage(`{"prompt":"Short prompt","subagent_type":"codegen"}`)
+	result := extractToolInput("Task", input)
+	assert.Equal(t, "[codegen] Short prompt", result)
+}
+
+func TestExtractToolInput_UnknownTool_Good(t *testing.T) {
+	input := json.RawMessage(`{"alpha":"one","beta":"two"}`)
+	result := extractToolInput("CustomTool", input)
+	// Fallback: sorted keys
+	assert.Equal(t, "alpha, beta", result)
+}
+
+func TestExtractToolInput_NilInput_Bad(t *testing.T) {
+	result := extractToolInput("Bash", nil)
+	assert.Equal(t, "", result)
+}
+
+func TestExtractToolInput_InvalidJSON_Bad(t *testing.T) {
+	input := json.RawMessage(`{broken`)
+	result := extractToolInput("Bash", input)
+	// All unmarshals fail, including the fallback map unmarshal
+	assert.Equal(t, "", result)
+}
+
+// --- extractResultContent tests ---
+
+func TestExtractResultContent_String_Good(t *testing.T) {
+	result := extractResultContent("simple string")
+	assert.Equal(t, "simple string", result)
+}
+
+func TestExtractResultContent_Array_Good(t *testing.T) {
+	content := []interface{}{
+		map[string]interface{}{"type": "text", "text": "line one"},
+		map[string]interface{}{"type": "text", "text": "line two"},
+	}
+	result := extractResultContent(content)
+	assert.Equal(t, "line one\nline two", result)
+}
+
+func TestExtractResultContent_Map_Good(t *testing.T) {
+	content := map[string]interface{}{"text": "from map"}
+	result := extractResultContent(content)
+	assert.Equal(t, "from map", result)
+}
+
+func TestExtractResultContent_Other_Bad(t *testing.T) {
+	result := extractResultContent(42)
+	assert.Equal(t, "42", result)
+}
+
+// --- truncate tests ---
+
+func TestTruncate_Short_Good(t *testing.T) {
+	assert.Equal(t, "hello", truncate("hello", 10))
+}
+
+func TestTruncate_Exact_Good(t *testing.T) {
+	assert.Equal(t, "hello", truncate("hello", 5))
+}
+
+func TestTruncate_Long_Good(t *testing.T) {
+	result := truncate("hello world", 5)
+	assert.Equal(t, "hello...", result)
+}
+
+func TestTruncate_Empty_Good(t *testing.T) {
+	assert.Equal(t, "", truncate("", 10))
+}
+
+// --- helper function tests ---
+
+func TestShortID_Good(t *testing.T) {
+	assert.Equal(t, "abcdefgh", shortID("abcdefghijklmnop"))
+	assert.Equal(t, "short", shortID("short"))
+	assert.Equal(t, "12345678", shortID("12345678"))
+}
+
+func TestFormatDuration_Good(t *testing.T) {
+	assert.Equal(t, "500ms", formatDuration(500*time.Millisecond))
+	assert.Equal(t, "1.5s", formatDuration(1500*time.Millisecond))
+	assert.Equal(t, "2m30s", formatDuration(2*time.Minute+30*time.Second))
+	assert.Equal(t, "1h5m", formatDuration(1*time.Hour+5*time.Minute))
 }
diff --git a/search_test.go b/search_test.go
index 4f1f6ab..e9cec22 100644
--- a/search_test.go
+++ b/search_test.go
@@ -1,173 +1,146 @@
+// SPDX-Licence-Identifier: EUPL-1.2
 package session
 
 import (
 	"os"
 	"path/filepath"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestSearch_FindsMatchingToolEvents(t *testing.T) {
+func TestSearch_EmptyDir_Good(t *testing.T) {
 	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"s1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_1","name":"Bash","input":{"command":"go test ./..."}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"s1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_1","content":"PASS"}]}}`,
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 2*time.Second) + `","sessionId":"s1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_2","name":"Grep","input":{"pattern":"TODO","path":"/src"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, 3*time.Second) + `","sessionId":"s1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_2","content":"main.go:42: // TODO fix this"}]}}`,
-	}
-	writeTempJSONL(t, dir, "session.jsonl", lines...)
 
-	t.Run("match_input", func(t *testing.T) {
-		results, err := Search(dir, "go test")
-		require.NoError(t, err)
-		require.Len(t, results, 1)
-		assert.Equal(t, "session", results[0].SessionID)
-		assert.Equal(t, "Bash", results[0].Tool)
-		assert.Contains(t, results[0].Match, "go test")
-	})
-
-	t.Run("match_output", func(t *testing.T) {
-		results, err := Search(dir, "TODO fix")
-		require.NoError(t, err)
-		require.Len(t, results, 1)
-		assert.Equal(t, "Grep", results[0].Tool)
-	})
-
-	t.Run("case_insensitive", func(t *testing.T) {
-		results, err := Search(dir, "PASS")
-		require.NoError(t, err)
-		require.Len(t, results, 1)
-	})
-
-	t.Run("no_match", func(t *testing.T) {
-		results, err := Search(dir, "nonexistent query")
-		require.NoError(t, err)
-		assert.Empty(t, results)
-	})
-}
-
-func TestSearch_SkipsNonToolEvents(t *testing.T) {
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"s2","message":{"role":"user","content":[{"type":"text","text":"find all TODO items"}]}}`,
-		`{"type":"assistant","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"s2","message":{"role":"assistant","content":[{"type":"text","text":"I will search for TODO items."}]}}`,
-	}
-	writeTempJSONL(t, dir, "notool.jsonl", lines...)
-
-	// The text "TODO" exists in user and assistant messages but Search only
-	// looks at tool_use events.
-	results, err := Search(dir, "TODO")
-	require.NoError(t, err)
-	assert.Empty(t, results)
-}
-
-func TestSearch_EmptyDirectory(t *testing.T) {
-	dir := t.TempDir()
 	results, err := Search(dir, "anything")
 	require.NoError(t, err)
 	assert.Empty(t, results)
 }
 
-func TestSearch_MultipleSessions(t *testing.T) {
+func TestSearch_NoMatches_Good(t *testing.T) {
 	dir := t.TempDir()
+	writeJSONL(t, dir, "session.jsonl",
+		toolUseEntry(ts(0), "Bash", "tool-1", map[string]interface{}{
+			"command": "ls -la",
+		}),
+		toolResultEntry(ts(1), "tool-1", "total 42", false),
+	)
 
-	// Session A has a matching tool call.
-	linesA := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"a","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_a","name":"Read","input":{"file_path":"/tmp/config.yaml"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"a","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_a","content":"port: 8080"}]}}`,
-	}
-	// Session B has a different matching tool call.
-	linesB := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"b","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_b","name":"Bash","input":{"command":"cat /tmp/config.yaml"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"b","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_b","content":"port: 8080"}]}}`,
-	}
-
-	writeTempJSONL(t, dir, "a.jsonl", linesA...)
-	writeTempJSONL(t, dir, "b.jsonl", linesB...)
-
-	results, err := Search(dir, "config.yaml")
-	require.NoError(t, err)
-	assert.Len(t, results, 2, "should find matches in both sessions")
-}
-
-func TestSearch_IgnoresNonJSONLFiles(t *testing.T) {
-	dir := t.TempDir()
-	// Write a .txt file containing the search term.
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("config.yaml"), 0644))
-
-	results, err := Search(dir, "config.yaml")
+	results, err := Search(dir, "nonexistent-query")
 	require.NoError(t, err)
 	assert.Empty(t, results)
 }
 
-func TestSearch_MalformedSessionSkipped(t *testing.T) {
+func TestSearch_SingleMatch_Good(t *testing.T) {
 	dir := t.TempDir()
-	// A completely invalid JSONL file.
-	writeTempJSONL(t, dir, "broken.jsonl", `{not valid json at all`)
-	// A valid session with a match.
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"ok","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_ok","name":"Bash","input":{"command":"echo found"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"ok","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_ok","content":"found"}]}}`,
-	}
-	writeTempJSONL(t, dir, "valid.jsonl", lines...)
+	writeJSONL(t, dir, "session.jsonl",
+		toolUseEntry(ts(0), "Bash", "tool-1", map[string]interface{}{
+			"command": "go test ./...",
+		}),
+		toolResultEntry(ts(1), "tool-1", "PASS ok mypackage 0.5s", false),
+	)
 
-	results, err := Search(dir, "found")
-	require.NoError(t, err)
-	assert.Len(t, results, 1, "should find match in valid session, ignoring broken one")
-}
-
-func TestSearch_MatchUsesInputAsContext(t *testing.T) {
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"ctx","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_ctx","name":"Bash","input":{"command":"deploy production"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"ctx","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_ctx","content":"deployed successfully"}]}}`,
-	}
-	writeTempJSONL(t, dir, "ctx.jsonl", lines...)
-
-	// Search matches on output but Match field should show input.
-	results, err := Search(dir, "deployed")
-	require.NoError(t, err)
-	require.Len(t, results, 1)
-	assert.Contains(t, results[0].Match, "deploy production",
-		"Match context should be the tool input, not output")
-}
-
-func TestSearch_MatchFallsBackToOutput(t *testing.T) {
-	// When a tool_use event has empty input but matching output, Match should
-	// show the (truncated) output. We simulate this by creating a session
-	// where the tool input resolves to empty.
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"fb","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_fb","name":"Bash","input":{}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"fb","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_fb","content":"fallback output text"}]}}`,
-	}
-	writeTempJSONL(t, dir, "fallback.jsonl", lines...)
-
-	results, err := Search(dir, "fallback output")
-	require.NoError(t, err)
-	require.Len(t, results, 1)
-	assert.Contains(t, results[0].Match, "fallback output")
-}
-
-func TestSearchResult_Fields(t *testing.T) {
-	// Verify that SearchResult fields are populated correctly.
-	dir := t.TempDir()
-	lines := []string{
-		`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"fields","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_f","name":"Grep","input":{"pattern":"error","path":"/var/log"}}]}}`,
-		`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"fields","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_f","content":"found 3 errors"}]}}`,
-	}
-	writeTempJSONL(t, dir, "fields.jsonl", lines...)
-
-	results, err := Search(dir, "error")
+	results, err := Search(dir, "go test")
 	require.NoError(t, err)
 	require.Len(t, results, 1)
 
-	r := results[0]
-	assert.Equal(t, "fields", r.SessionID)
-	assert.False(t, r.Timestamp.IsZero())
-	assert.Equal(t, "Grep", r.Tool)
-	assert.NotEmpty(t, r.Match)
+	assert.Equal(t, "session", results[0].SessionID)
+	assert.Equal(t, "Bash", results[0].Tool)
+	assert.Contains(t, results[0].Match, "go test")
+}
+
+func TestSearch_MultipleMatches_Good(t *testing.T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "session1.jsonl",
+		toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
+			"command": "go test ./...",
+		}),
+		toolResultEntry(ts(1), "t1", "PASS", false),
+		toolUseEntry(ts(2), "Bash", "t2", map[string]interface{}{
+			"command": "go test -race ./...",
+		}),
+		toolResultEntry(ts(3), "t2", "PASS", false),
+	)
+	writeJSONL(t, dir, "session2.jsonl",
+		toolUseEntry(ts(0), "Bash", "t3", map[string]interface{}{
+			"command": "go test -bench=.",
+		}),
+		toolResultEntry(ts(1), "t3", "PASS", false),
+	)
+
+	results, err := Search(dir, "go test")
+	require.NoError(t, err)
+	assert.Len(t, results, 3, "should find matches across both sessions")
+}
+
+func TestSearch_CaseInsensitive_Good(t *testing.T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "session.jsonl",
+		toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
+			"command": "GO TEST ./...",
+		}),
+		toolResultEntry(ts(1), "t1", "PASS", false),
+	)
+
+	results, err := Search(dir, "go test")
+	require.NoError(t, err)
+	assert.Len(t, results, 1, "search should be case-insensitive")
+}
+
+func TestSearch_MatchesInOutput_Good(t *testing.T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "session.jsonl",
+		toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
+			"command": "cat log.txt",
+		}),
+		toolResultEntry(ts(1), "t1", "ERROR: connection refused to database", false),
+	)
+
+	results, err := Search(dir, "connection refused")
+	require.NoError(t, err)
+	require.Len(t, results, 1, "should match against output text")
+	// Match field should contain the input (command) since it's non-empty
+	assert.Contains(t, results[0].Match, "cat log.txt")
+}
+
+func TestSearch_SkipsNonToolEvents_Good(t *testing.T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "session.jsonl",
+		userTextEntry(ts(0), "Please search for something"),
+		assistantTextEntry(ts(1), "I will search for something"),
+	)
+
+	// "search" appears in user and assistant text, but Search only checks tool_use events
+	results, err := Search(dir, "search")
+	require.NoError(t, err)
+	assert.Empty(t, results, "should only match tool_use events, not user/assistant text")
+}
+
+func TestSearch_NonJSONLIgnored_Good(t *testing.T) {
+	dir := t.TempDir()
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "readme.md"), []byte("go test"), 0644))
+
+	results, err := Search(dir, "go test")
+	require.NoError(t, err)
+	assert.Empty(t, results, "non-JSONL files should be ignored")
+}
+
+func TestSearch_MalformedSessionSkipped_Bad(t *testing.T) {
+	dir := t.TempDir()
+
+	// One broken session and one valid session
+	writeJSONL(t, dir, "broken.jsonl",
+		`{not valid json at all`,
+	)
+	writeJSONL(t, dir, "valid.jsonl",
+		toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
+			"command": "go test ./...",
+		}),
+		toolResultEntry(ts(1), "t1", "PASS", false),
+	)
+
+	results, err := Search(dir, "go test")
+	require.NoError(t, err)
+	assert.Len(t, results, 1, "should still find matches in valid sessions")
 }
diff --git a/video_test.go b/video_test.go
index b33f04f..7a195ce 100644
--- a/video_test.go
+++ b/video_test.go
@@ -1,6 +1,8 @@
+// SPDX-Licence-Identifier: EUPL-1.2
 package session
 
 import (
+	"os/exec"
 	"strings"
 	"testing"
 	"time"
@@ -9,219 +11,197 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// NOTE: RenderMP4 requires the external `vhs` binary and writes to temp files
-// then calls exec. We test generateTape (the pure logic) directly, and verify
-// RenderMP4 returns a sensible error when vhs is absent.
-
-func TestRenderMP4_VHSNotInstalled(t *testing.T) {
+func TestGenerateTape_BasicSession_Good(t *testing.T) {
 	sess := &Session{
-		ID:        "video-test",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(time.Minute),
-	}
-
-	err := RenderMP4(sess, "/tmp/out.mp4")
-	if err == nil {
-		t.Skip("vhs is installed on this system; skipping missing-binary test")
-	}
-	assert.Contains(t, err.Error(), "vhs not installed")
-}
-
-func TestGenerateTape_EmptySession(t *testing.T) {
-	sess := &Session{
-		ID:        "empty-tape",
-		StartTime: baseTime,
-		EndTime:   baseTime,
-		Events:    nil,
-	}
-
-	tape := generateTape(sess, "/tmp/empty.mp4")
-
-	assert.Contains(t, tape, "Output /tmp/empty.mp4")
-	assert.Contains(t, tape, "Set FontSize 16")
-	assert.Contains(t, tape, "Set Width 1400")
-	assert.Contains(t, tape, "Set Height 800")
-	assert.Contains(t, tape, "Set Theme")
-	assert.Contains(t, tape, "# Session empty-ta")
-	assert.Contains(t, tape, "Sleep 3s") // Final sleep
-}
-
-func TestGenerateTape_BashEvents(t *testing.T) {
-	sess := &Session{
-		ID:        "bash-tape-session-long-id",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(10 * time.Second),
+		ID:        "tape-test-12345678",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 		Events: []Event{
 			{
 				Type:    "tool_use",
 				Tool:    "Bash",
-				Input:   "ls -la # list files",
-				Output:  "total 10\nfile1.go\nfile2.go",
+				Input:   "go test ./...",
+				Output:  "PASS",
 				Success: true,
 			},
 			{
-				Type:     "tool_use",
-				Tool:     "Bash",
-				Input:    "false",
-				Output:   "exit 1",
-				Success:  false,
-				ErrorMsg: "exit 1",
+				Type:    "tool_use",
+				Tool:    "Read",
+				Input:   "/tmp/file.go",
+				Output:  "package main",
+				Success: true,
 			},
 		},
 	}
 
-	tape := generateTape(sess, "/tmp/bash.mp4")
+	tape := generateTape(sess, "/tmp/output.mp4")
 
-	t.Run("title_uses_short_id", func(t *testing.T) {
-		assert.Contains(t, tape, "# Session bash-tap")
-	})
-
-	t.Run("bash_command_shown", func(t *testing.T) {
-		assert.Contains(t, tape, `"$ ls -la"`)
-	})
-
-	t.Run("bash_output_shown", func(t *testing.T) {
-		assert.Contains(t, tape, "file1.go")
-	})
-
-	t.Run("success_indicator", func(t *testing.T) {
-		assert.Contains(t, tape, "OK")
-	})
-
-	t.Run("failure_indicator", func(t *testing.T) {
-		assert.Contains(t, tape, "FAILED")
-	})
+	assert.Contains(t, tape, "Output /tmp/output.mp4")
+	assert.Contains(t, tape, "Set FontSize 16")
+	assert.Contains(t, tape, "tape-tes") // shortID
+	assert.Contains(t, tape, "2026-02-20 10:00")
+	assert.Contains(t, tape, `"$ go test ./..."`)
+	assert.Contains(t, tape, "PASS")
+	assert.Contains(t, tape, `"# ✓ OK"`)
+	assert.Contains(t, tape, "# Read: /tmp/file.go")
 }
 
-func TestGenerateTape_ReadEditWriteEvents(t *testing.T) {
-	sess := &Session{
-		ID:        "file-ops",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Second),
-		Events: []Event{
-			{Type: "tool_use", Tool: "Read", Input: "/tmp/foo.go", Success: true},
-			{Type: "tool_use", Tool: "Edit", Input: "/tmp/foo.go (edit)", Success: true},
-			{Type: "tool_use", Tool: "Write", Input: "/tmp/bar.go (100 bytes)", Success: true},
-		},
-	}
-
-	tape := generateTape(sess, "/tmp/files.mp4")
-
-	assert.Contains(t, tape, "# Read: /tmp/foo.go")
-	assert.Contains(t, tape, "# Edit: /tmp/foo.go (edit)")
-	assert.Contains(t, tape, "# Write: /tmp/bar.go (100 bytes)")
-}
-
-func TestGenerateTape_TaskEvents(t *testing.T) {
-	sess := &Session{
-		ID:        "task-session",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Second),
-		Events: []Event{
-			{Type: "tool_use", Tool: "Task", Input: "[research] summarise the codebase", Success: true},
-		},
-	}
-
-	tape := generateTape(sess, "/tmp/task.mp4")
-	assert.Contains(t, tape, "# Agent: [research] summarise the codebase")
-}
-
-func TestGenerateTape_SkipsNonToolEvents(t *testing.T) {
+func TestGenerateTape_SkipsNonToolEvents_Good(t *testing.T) {
 	sess := &Session{
 		ID:        "skip-test",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Second),
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 		Events: []Event{
-			{Type: "user", Input: "user message"},
-			{Type: "assistant", Input: "assistant message"},
-			{Type: "tool_use", Tool: "Bash", Input: "echo ok", Output: "ok", Success: true},
+			{Type: "user", Input: "Hello"},
+			{Type: "assistant", Input: "Hi there"},
+			{Type: "tool_use", Tool: "Bash", Input: "echo hi", Output: "hi", Success: true},
 		},
 	}
 
-	tape := generateTape(sess, "/tmp/skip.mp4")
+	tape := generateTape(sess, "/tmp/out.mp4")
 
-	// User and assistant messages should not appear as typed commands.
-	assert.NotContains(t, tape, "user message")
-	assert.NotContains(t, tape, "assistant message")
-	assert.Contains(t, tape, "$ echo ok")
+	// User and assistant events should NOT appear in the tape
+	assert.NotContains(t, tape, "Hello")
+	assert.NotContains(t, tape, "Hi there")
+	// Bash command should appear
+	assert.Contains(t, tape, "echo hi")
 }
 
-func TestGenerateTape_LongOutputTruncated(t *testing.T) {
-	longOutput := strings.Repeat("x", 500)
+func TestGenerateTape_FailedCommand_Good(t *testing.T) {
 	sess := &Session{
-		ID:        "trunc-out",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Second),
+		ID:        "fail-test",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 		Events: []Event{
-			{Type: "tool_use", Tool: "Bash", Input: "cmd", Output: longOutput, Success: true},
+			{
+				Type:    "tool_use",
+				Tool:    "Bash",
+				Input:   "cat /missing",
+				Output:  "No such file",
+				Success: false,
+			},
 		},
 	}
 
-	tape := generateTape(sess, "/tmp/trunc.mp4")
-	// Output in the tape should be truncated at 200 chars + "...".
-	assert.Contains(t, tape, "...")
-	// The full 500-char string should not appear.
-	assert.NotContains(t, tape, longOutput)
+	tape := generateTape(sess, "/tmp/out.mp4")
+	assert.Contains(t, tape, `"# ✗ FAILED"`)
 }
 
-func TestGenerateTape_EmptyBashCommand(t *testing.T) {
+func TestGenerateTape_LongOutput_Good(t *testing.T) {
+	sess := &Session{
+		ID:        "long-test",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		Events: []Event{
+			{
+				Type:    "tool_use",
+				Tool:    "Bash",
+				Input:   "cat huge.log",
+				Output:  strings.Repeat("x", 300),
+				Success: true,
+			},
+		},
+	}
+
+	tape := generateTape(sess, "/tmp/out.mp4")
+	// Output should be truncated to 200 chars + "..."
+	assert.Contains(t, tape, "...")
+}
+
+func TestGenerateTape_TaskEvent_Good(t *testing.T) {
+	sess := &Session{
+		ID:        "task-test",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		Events: []Event{
+			{
+				Type:  "tool_use",
+				Tool:  "Task",
+				Input: "[research] Analyse code structure",
+			},
+		},
+	}
+
+	tape := generateTape(sess, "/tmp/out.mp4")
+	assert.Contains(t, tape, "# Agent: [research] Analyse code structure")
+}
+
+func TestGenerateTape_EditWriteEvents_Good(t *testing.T) {
+	sess := &Session{
+		ID:        "edit-test",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		Events: []Event{
+			{Type: "tool_use", Tool: "Edit", Input: "/tmp/app.go (edit)"},
+			{Type: "tool_use", Tool: "Write", Input: "/tmp/new.go (50 bytes)"},
+		},
+	}
+
+	tape := generateTape(sess, "/tmp/out.mp4")
+	assert.Contains(t, tape, "# Edit: /tmp/app.go (edit)")
+	assert.Contains(t, tape, "# Write: /tmp/new.go (50 bytes)")
+}
+
+func TestGenerateTape_EmptySession_Good(t *testing.T) {
+	sess := &Session{
+		ID:        "empty-test",
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
+		Events:    nil,
+	}
+
+	tape := generateTape(sess, "/tmp/out.mp4")
+
+	// Should still have the header and trailer
+	assert.Contains(t, tape, "Output /tmp/out.mp4")
+	assert.Contains(t, tape, "Sleep 3s")
+	// No tool events
+	lines := strings.Split(tape, "\n")
+	var toolLines int
+	for _, line := range lines {
+		if strings.Contains(line, "$ ") || strings.Contains(line, "# Read:") ||
+			strings.Contains(line, "# Edit:") || strings.Contains(line, "# Write:") {
+			toolLines++
+		}
+	}
+	assert.Equal(t, 0, toolLines)
+}
+
+func TestGenerateTape_BashEmptyCommand_Bad(t *testing.T) {
 	sess := &Session{
 		ID:        "empty-cmd",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(time.Second),
+		StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
 		Events: []Event{
-			{Type: "tool_use", Tool: "Bash", Input: "", Success: true},
+			{Type: "tool_use", Tool: "Bash", Input: "", Output: "", Success: true},
 		},
 	}
 
-	tape := generateTape(sess, "/tmp/empty-cmd.mp4")
-	// An empty command should be skipped (no "$ " line).
-	lines := strings.Split(tape, "\n")
-	for _, line := range lines {
-		assert.NotContains(t, line, `"$ "`)
-	}
+	tape := generateTape(sess, "/tmp/out.mp4")
+	// Empty command should be skipped (extractCommand returns "")
+	assert.NotContains(t, tape, `"$ "`)
 }
 
-func TestGenerateTape_SkipsGrepGlob(t *testing.T) {
-	// Grep and Glob tool_use events are not handled in the switch,
-	// so they should produce no typed output in the tape.
+func TestExtractCommand_Good(t *testing.T) {
+	assert.Equal(t, "ls -la", extractCommand("ls -la # list files"))
+	assert.Equal(t, "go test ./...", extractCommand("go test ./..."))
+	assert.Equal(t, "echo hello", extractCommand("echo hello"))
+}
+
+func TestExtractCommand_NoDescription_Good(t *testing.T) {
+	assert.Equal(t, "plain command", extractCommand("plain command"))
+}
+
+func TestExtractCommand_DescriptionAtStart_Good(t *testing.T) {
+	// " # " at position 0 means idx <= 0, so it returns the whole input
+	result := extractCommand(" # description only")
+	assert.Equal(t, " # description only", result)
+}
+
+func TestRenderMP4_NoVHS_Ugly(t *testing.T) {
+	// Skip if vhs is actually installed (this tests the error path)
+	if _, err := exec.LookPath("vhs"); err == nil {
+		t.Skip("vhs is installed; skipping missing-vhs test")
+	}
+
 	sess := &Session{
-		ID:        "grep-glob",
-		StartTime: baseTime,
-		EndTime:   baseTime.Add(5 * time.Second),
-		Events: []Event{
-			{Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Success: true},
-			{Type: "tool_use", Tool: "Glob", Input: "**/*.go", Success: true},
-		},
+		ID:        "no-vhs",
+		StartTime: time.Now(),
 	}
 
-	tape := generateTape(sess, "/tmp/gg.mp4")
-	// Title and settings should exist, but no Grep/Glob content.
-	assert.Contains(t, tape, "Output /tmp/gg.mp4")
-	assert.NotContains(t, tape, "TODO")
-	assert.NotContains(t, tape, "*.go")
-}
-
-// -- extractCommand tests --
-
-func TestExtractCommand(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-		want  string
-	}{
-		{"with description", "ls -la # list files", "ls -la"},
-		{"without description", "pwd", "pwd"},
-		// extractCommand naively splits on first " # " so embedded hashes are truncated.
-		{"hash in command", "echo 'hello # world'", "echo 'hello"},
-		{"description at start", " # desc", " # desc"}, // idx == 0, not > 0
-		{"empty", "", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := extractCommand(tt.input)
-			require.Equal(t, tt.want, got)
-		})
-	}
+	err := RenderMP4(sess, "/tmp/test.mp4")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "vhs not installed")
 }