From 38d5cff0e53f29de86720a49862ef09c82d0d129 Mon Sep 17 00:00:00 2001
From: Snider <snider@host.uk.com>
Date: Sat, 25 Apr 2026 02:37:22 +0100
Subject: [PATCH] =?UTF-8?q?release:=20v0.8.0-alpha.1=20=E2=80=94=20module?=
 =?UTF-8?q?=20migration,=20AX-6=20testify=20replacement,=20AX-10=20scaffol?=
 =?UTF-8?q?d?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Consolidates the v0.8.0-alpha.1 release work for core/go-session.

* Module path migration: forge.lthn.ai/core/go-session ->
  dappco.re/go/session. All sibling dappco.re/go/* deps pinned to
  v0.8.0-alpha.1.

* AX-6 testify removal: replaced testify assertions with stdlib
  testing patterns across the test suite. Removes external test
  framework dep in favour of the universal Core test contract.

* AX-6 annotation: intrinsic banned imports annotated where their
  use is structurally required (boundary functions, justified by
  comment).

* AX-10 scaffold: tests/cli/session/Taskfile.yaml + test driver
  for the session CLI surface.

* Stale path cleanup: minor housekeeping of references to the
  pre-migration module path.

Refs: RFC-CORE-008-AGENT-EXPERIENCE.md (AX-1, AX-6, AX-10)

Co-authored-by: Athena <athena@lthn.ai>
Co-authored-by: Hephaestus <hephaestus@lthn.ai>
Co-authored-by: Cladius Maximus <cladius@lthn.ai>
---
 analytics.go                    |   6 +-
 analytics_test.go               | 101 +++---
 conventions_test.go             |   2 +-
 core_helpers.go                 |   2 +-
 go.mod                          |  14 +-
 go.sum                          |  12 -
 html.go                         |   6 +-
 html_test.go                    |  84 +++--
 parser.go                       |  16 +-
 parser_test.go                  | 544 ++++++++++++++++----------------
 search.go                       |   8 +-
 search_test.go                  |  55 ++--
 test_helpers_test.go            | 179 +++++++++++
 tests/cli/session/Taskfile.yaml |  14 +
 tests/cli/session/main.go       |  82 +++++
 video.go                        |   6 +-
 video_test.go                   |  56 ++--
 17 files changed, 714 insertions(+), 473 deletions(-)
 create mode 100644 test_helpers_test.go
 create mode 100644 tests/cli/session/Taskfile.yaml
 create mode 100644 tests/cli/session/main.go

diff --git a/analytics.go b/analytics.go
index 98d2af7..40b4d14 100644
--- a/analytics.go
+++ b/analytics.go
@@ -2,9 +2,9 @@
 package session
 
 import (
-	"maps"
-	"slices"
-	"time"
+	"maps"   // Note: intrinsic — maps.Keys exposes tool names for deterministic analytics output; no core equivalent
+	"slices" // Note: intrinsic — slices.Sorted orders analytics rows deterministically; no core equivalent
+	"time"   // Note: intrinsic — time.Duration arithmetic for session, active-time, and latency metrics; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/analytics_test.go b/analytics_test.go
index 8900f84..b9e7499 100644
--- a/analytics_test.go
+++ b/analytics_test.go
@@ -4,9 +4,6 @@ package session
 import (
 	"testing"
 	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestAnalytics_AnalyseEmptySession_Good(t *testing.T) {
@@ -18,22 +15,22 @@ func TestAnalytics_AnalyseEmptySession_Good(t *testing.T) {
 	}
 
 	a := Analyse(sess)
-	require.NotNil(t, a)
+	requireNotNil(t, a)
 
-	assert.Equal(t, time.Duration(0), a.Duration)
-	assert.Equal(t, time.Duration(0), a.ActiveTime)
-	assert.Equal(t, 0, a.EventCount)
-	assert.Equal(t, 0.0, a.SuccessRate)
-	assert.Empty(t, a.ToolCounts)
-	assert.Empty(t, a.ErrorCounts)
-	assert.Equal(t, 0, a.EstimatedInputTokens)
-	assert.Equal(t, 0, a.EstimatedOutputTokens)
+	assertEqual(t, time.Duration(0), a.Duration)
+	assertEqual(t, time.Duration(0), a.ActiveTime)
+	assertEqual(t, 0, a.EventCount)
+	assertEqual(t, 0.0, a.SuccessRate)
+	assertEmpty(t, a.ToolCounts)
+	assertEmpty(t, a.ErrorCounts)
+	assertEqual(t, 0, a.EstimatedInputTokens)
+	assertEqual(t, 0, a.EstimatedOutputTokens)
 }
 
 func TestAnalytics_AnalyseNilSession_Good(t *testing.T) {
 	a := Analyse(nil)
-	require.NotNil(t, a)
-	assert.Equal(t, 0, a.EventCount)
+	requireNotNil(t, a)
+	assertEqual(t, 0, a.EventCount)
 }
 
 func TestAnalytics_AnalyseSingleToolCall_Good(t *testing.T) {
@@ -56,14 +53,14 @@ func TestAnalytics_AnalyseSingleToolCall_Good(t *testing.T) {
 
 	a := Analyse(sess)
 
-	assert.Equal(t, 5*time.Second, a.Duration)
-	assert.Equal(t, 2*time.Second, a.ActiveTime)
-	assert.Equal(t, 1, a.EventCount)
-	assert.Equal(t, 1.0, a.SuccessRate)
-	assert.Equal(t, 1, a.ToolCounts["Bash"])
-	assert.Equal(t, 0, a.ErrorCounts["Bash"])
-	assert.Equal(t, 2*time.Second, a.AvgLatency["Bash"])
-	assert.Equal(t, 2*time.Second, a.MaxLatency["Bash"])
+	assertEqual(t, 5*time.Second, a.Duration)
+	assertEqual(t, 2*time.Second, a.ActiveTime)
+	assertEqual(t, 1, a.EventCount)
+	assertEqual(t, 1.0, a.SuccessRate)
+	assertEqual(t, 1, a.ToolCounts["Bash"])
+	assertEqual(t, 0, a.ErrorCounts["Bash"])
+	assertEqual(t, 2*time.Second, a.AvgLatency["Bash"])
+	assertEqual(t, 2*time.Second, a.MaxLatency["Bash"])
 }
 
 func TestAnalytics_AnalyseMixedToolsWithErrors_Good(t *testing.T) {
@@ -127,24 +124,24 @@ func TestAnalytics_AnalyseMixedToolsWithErrors_Good(t *testing.T) {
 
 	a := Analyse(sess)
 
-	assert.Equal(t, 5*time.Minute, a.Duration)
-	assert.Equal(t, 7, a.EventCount)
+	assertEqual(t, 5*time.Minute, a.Duration)
+	assertEqual(t, 7, a.EventCount)
 
 	// Tool counts
-	assert.Equal(t, 2, a.ToolCounts["Bash"])
-	assert.Equal(t, 2, a.ToolCounts["Read"])
-	assert.Equal(t, 1, a.ToolCounts["Edit"])
+	assertEqual(t, 2, a.ToolCounts["Bash"])
+	assertEqual(t, 2, a.ToolCounts["Read"])
+	assertEqual(t, 1, a.ToolCounts["Edit"])
 
 	// Error counts
-	assert.Equal(t, 1, a.ErrorCounts["Bash"])
-	assert.Equal(t, 1, a.ErrorCounts["Read"])
-	assert.Equal(t, 0, a.ErrorCounts["Edit"])
+	assertEqual(t, 1, a.ErrorCounts["Bash"])
+	assertEqual(t, 1, a.ErrorCounts["Read"])
+	assertEqual(t, 0, a.ErrorCounts["Edit"])
 
 	// Success rate: 3 successes out of 5 tool calls = 0.6
-	assert.InDelta(t, 0.6, a.SuccessRate, 0.001)
+	assertInDelta(t, 0.6, a.SuccessRate, 0.001)
 
 	// Active time: 1s + 500ms + 200ms + 100ms + 300ms = 2.1s
-	assert.Equal(t, 2100*time.Millisecond, a.ActiveTime)
+	assertEqual(t, 2100*time.Millisecond, a.ActiveTime)
 }
 
 func TestAnalytics_AnalyseLatencyCalculations_Good(t *testing.T) {
@@ -183,12 +180,12 @@ func TestAnalytics_AnalyseLatencyCalculations_Good(t *testing.T) {
 	a := Analyse(sess)
 
 	// Bash: avg = (1+3+5)/3 = 3s, max = 5s
-	assert.Equal(t, 3*time.Second, a.AvgLatency["Bash"])
-	assert.Equal(t, 5*time.Second, a.MaxLatency["Bash"])
+	assertEqual(t, 3*time.Second, a.AvgLatency["Bash"])
+	assertEqual(t, 5*time.Second, a.MaxLatency["Bash"])
 
 	// Read: avg = 200ms, max = 200ms
-	assert.Equal(t, 200*time.Millisecond, a.AvgLatency["Read"])
-	assert.Equal(t, 200*time.Millisecond, a.MaxLatency["Read"])
+	assertEqual(t, 200*time.Millisecond, a.AvgLatency["Read"])
+	assertEqual(t, 200*time.Millisecond, a.MaxLatency["Read"])
 }
 
 func TestAnalytics_AnalyseTokenEstimation_Good(t *testing.T) {
@@ -220,9 +217,9 @@ func TestAnalytics_AnalyseTokenEstimation_Good(t *testing.T) {
 	a := Analyse(sess)
 
 	// Input tokens: 400/4 + 80/4 + 120/4 = 100 + 20 + 30 = 150
-	assert.Equal(t, 150, a.EstimatedInputTokens)
+	assertEqual(t, 150, a.EstimatedInputTokens)
 	// Output tokens: 0 + 200/4 + 0 = 50
-	assert.Equal(t, 50, a.EstimatedOutputTokens)
+	assertEqual(t, 50, a.EstimatedOutputTokens)
 }
 
 func TestAnalytics_FormatAnalyticsOutput_Good(t *testing.T) {
@@ -255,17 +252,17 @@ func TestAnalytics_FormatAnalyticsOutput_Good(t *testing.T) {
 
 	output := FormatAnalytics(a)
 
-	assert.Contains(t, output, "Session Analytics")
-	assert.Contains(t, output, "5m0s")
-	assert.Contains(t, output, "2m0s")
-	assert.Contains(t, output, "42")
-	assert.Contains(t, output, "85.0%")
-	assert.Contains(t, output, "1500")
-	assert.Contains(t, output, "3000")
-	assert.Contains(t, output, "Bash")
-	assert.Contains(t, output, "Read")
-	assert.Contains(t, output, "Edit")
-	assert.Contains(t, output, "Tool Breakdown")
+	assertContains(t, output, "Session Analytics")
+	assertContains(t, output, "5m0s")
+	assertContains(t, output, "2m0s")
+	assertContains(t, output, "42")
+	assertContains(t, output, "85.0%")
+	assertContains(t, output, "1500")
+	assertContains(t, output, "3000")
+	assertContains(t, output, "Bash")
+	assertContains(t, output, "Read")
+	assertContains(t, output, "Edit")
+	assertContains(t, output, "Tool Breakdown")
 }
 
 func TestAnalytics_FormatAnalyticsEmptyAnalytics_Good(t *testing.T) {
@@ -278,8 +275,8 @@ func TestAnalytics_FormatAnalyticsEmptyAnalytics_Good(t *testing.T) {
 
 	output := FormatAnalytics(a)
 
-	assert.Contains(t, output, "Session Analytics")
-	assert.Contains(t, output, "0.0%")
+	assertContains(t, output, "Session Analytics")
+	assertContains(t, output, "0.0%")
 	// No tool breakdown section when no tools
-	assert.NotContains(t, output, "Tool Breakdown")
+	assertNotContains(t, output, "Tool Breakdown")
 }
diff --git a/conventions_test.go b/conventions_test.go
index f6bbd4e..d292cfc 100644
--- a/conventions_test.go
+++ b/conventions_test.go
@@ -33,7 +33,7 @@ func TestConventions_BannedImports_Good(t *testing.T) {
 		for _, spec := range file.ast.Imports {
 			importPath := trimQuotes(spec.Path.Value)
 			if core.HasPrefix(importPath, "forge.lthn.ai/") {
-				t.Errorf("%s imports %q; use dappco.re/go/core/... paths instead", file.path, importPath)
+				t.Errorf("%s imports %q; use dappco.re/go/... paths instead", file.path, importPath)
 				continue
 			}
 			if reason, ok := banned[importPath]; ok {
diff --git a/core_helpers.go b/core_helpers.go
index af0040b..886374a 100644
--- a/core_helpers.go
+++ b/core_helpers.go
@@ -2,7 +2,7 @@
 package session
 
 import (
-	"bytes"
+	"bytes" // Note: intrinsic — byte-slice helpers implement local string primitives without strings import; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/go.mod b/go.mod
index 11183d1..fb10cc3 100644
--- a/go.mod
+++ b/go.mod
@@ -1,15 +1,5 @@
-module dappco.re/go/core/session
+module dappco.re/go/session
 
 go 1.26.0
 
-require (
-	dappco.re/go/core v0.8.0-alpha.1
-	github.com/stretchr/testify v1.11.1
-)
-
-require (
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
+require dappco.re/go/core v0.8.0-alpha.1
diff --git a/go.sum b/go.sum
index 5092fed..c8d1dca 100644
--- a/go.sum
+++ b/go.sum
@@ -1,20 +1,8 @@
 dappco.re/go/core v0.8.0-alpha.1 h1:gj7+Scv+L63Z7wMxbJYHhaRFkHJo2u4MMPuUSv/Dhtk=
 dappco.re/go/core v0.8.0-alpha.1/go.mod h1:f2/tBZ3+3IqDrg2F5F598llv0nmb/4gJVCFzM5geE4A=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/html.go b/html.go
index 431ee5e..44bb358 100644
--- a/html.go
+++ b/html.go
@@ -2,9 +2,9 @@
 package session
 
 import (
-	"html"
-	"path"
-	"time"
+	"html" // Note: intrinsic — escaping transcript content for generated HTML; stdlib encoder is the output contract
+	"path" // Note: intrinsic — output parent directory derivation for slash-separated paths; no core equivalent
+	"time" // Note: intrinsic — duration formatting thresholds for rendered summaries; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/html_test.go b/html_test.go
index 1dd9c69..3830c48 100644
--- a/html_test.go
+++ b/html_test.go
@@ -6,8 +6,6 @@ import (
 	"time"
 
 	core "dappco.re/go/core"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestHTML_RenderHTMLBasicSession_Good(t *testing.T) {
@@ -54,30 +52,30 @@ func TestHTML_RenderHTMLBasicSession_Good(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	readResult := hostFS.Read(outputPath)
-	require.True(t, readResult.OK)
+	requireTrue(t, readResult.OK)
 	html := readResult.Value.(string)
 
 	// 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")
-	assert.Contains(t, html, `href="#evt-0"`)
-	assert.Contains(t, html, "openHashEvent")
+	assertContains(t, html, "<!DOCTYPE html>")
+	assertContains(t, html, "test-ses") // shortID of "test-session-12345678"
+	assertContains(t, html, "2026-02-20 10:00:00")
+	assertContains(t, html, "5m30s") // duration
+	assertContains(t, html, "2 tool calls")
+	assertContains(t, html, "ls -la")
+	assertContains(t, html, "total 42")
+	assertContains(t, html, "/tmp/file.go")
+	assertContains(t, html, "User")   // user event label
+	assertContains(t, html, "Claude") // assistant event label
+	assertContains(t, html, "Bash")
+	assertContains(t, html, "Read")
+	assertContains(t, html, `href="#evt-0"`)
+	assertContains(t, html, "openHashEvent")
 	// Should contain JS for toggle and filter
-	assert.Contains(t, html, "function toggle")
-	assert.Contains(t, html, "function filterEvents")
+	assertContains(t, html, "function toggle")
+	assertContains(t, html, "function filterEvents")
 }
 
 func TestHTML_RenderHTMLEmptySession_Good(t *testing.T) {
@@ -93,15 +91,15 @@ func TestHTML_RenderHTMLEmptySession_Good(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	readResult := hostFS.Read(outputPath)
-	require.True(t, readResult.OK)
+	requireTrue(t, readResult.OK)
 	html := readResult.Value.(string)
-	assert.Contains(t, html, "<!DOCTYPE html>")
-	assert.Contains(t, html, "0 tool calls")
+	assertContains(t, html, "<!DOCTYPE html>")
+	assertContains(t, html, "0 tool calls")
 	// Should NOT contain error span
-	assert.NotContains(t, html, "errors</span>")
+	assertNotContains(t, html, "errors</span>")
 }
 
 func TestHTML_RenderHTMLWithErrors_Good(t *testing.T) {
@@ -137,15 +135,15 @@ func TestHTML_RenderHTMLWithErrors_Good(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	readResult := hostFS.Read(outputPath)
-	require.True(t, readResult.OK)
+	requireTrue(t, readResult.OK)
 	html := readResult.Value.(string)
-	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
+	assertContains(t, html, "1 errors")
+	assertContains(t, html, `class="event error"`)
+	assertContains(t, html, "&#10007;") // cross mark for failed
+	assertContains(t, html, "&#10003;") // check mark for success
 }
 
 func TestHTML_RenderHTMLSpecialCharacters_Good(t *testing.T) {
@@ -176,16 +174,16 @@ func TestHTML_RenderHTMLSpecialCharacters_Good(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	readResult := hostFS.Read(outputPath)
-	require.True(t, readResult.OK)
+	requireTrue(t, readResult.OK)
 	html := readResult.Value.(string)
 
 	// 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;")
+	assertNotContains(t, html, "<script>alert")
+	assertContains(t, html, "&lt;script&gt;")
+	assertContains(t, html, "&amp;")
 }
 
 func TestHTML_RenderHTMLInvalidPath_Ugly(t *testing.T) {
@@ -195,8 +193,8 @@ func TestHTML_RenderHTMLInvalidPath_Ugly(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, "/nonexistent/dir/output.html")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "parent directory does not exist")
+	requireError(t, err)
+	assertContains(t, err.Error(), "parent directory does not exist")
 }
 
 func TestHTML_RenderHTMLLabelsByToolType_Good(t *testing.T) {
@@ -219,16 +217,16 @@ func TestHTML_RenderHTMLLabelsByToolType_Good(t *testing.T) {
 	}
 
 	err := RenderHTML(sess, outputPath)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	readResult := hostFS.Read(outputPath)
-	require.True(t, readResult.OK)
+	requireTrue(t, readResult.OK)
 	html := readResult.Value.(string)
 
 	// Bash gets "Command" label
-	assert.True(t, core.Contains(html, "Command"), "Bash events should use 'Command' label")
+	assertTrue(t, core.Contains(html, "Command"), "Bash events should use 'Command' label")
 	// Read, Glob, Grep get "Target" label
-	assert.True(t, core.Contains(html, "Target"), "Read/Glob/Grep events should use 'Target' label")
+	assertTrue(t, core.Contains(html, "Target"), "Read/Glob/Grep events should use 'Target' label")
 	// Edit, Write get "File" label
-	assert.True(t, core.Contains(html, "File"), "Edit/Write events should use 'File' label")
+	assertTrue(t, core.Contains(html, "File"), "Edit/Write events should use 'File' label")
 }
diff --git a/parser.go b/parser.go
index 761ea40..3e6bd5e 100644
--- a/parser.go
+++ b/parser.go
@@ -2,14 +2,14 @@
 package session
 
 import (
-	"bufio"
-	"io"
-	"io/fs"
-	"iter"
-	"maps"
-	"path"
-	"slices"
-	"time"
+	"bufio"  // Note: intrinsic — streaming JSONL scan with an explicit bounded buffer; no core equivalent
+	"io"     // Note: intrinsic — Reader and ReadCloser contracts for transcript streams and hostFS handles; no core equivalent
+	"io/fs"  // Note: intrinsic — fs.FileInfo metadata returned from hostFS.Stat; no core equivalent
+	"iter"   // Note: intrinsic — public lazy sequence API for sessions and events; no core equivalent
+	"maps"   // Note: intrinsic — maps.Keys exposes JSON fallback key sets for deterministic output; no core equivalent
+	"path"   // Note: intrinsic — slash-separated transcript path joining and base-name extraction; no core equivalent
+	"slices" // Note: intrinsic — iterator collection, sorted keys, and session ordering; no core equivalent
+	"time"   // Note: intrinsic — RFC3339 transcript timestamps and session age calculations; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/parser_test.go b/parser_test.go
index 6488ac2..b43aac8 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -9,8 +9,6 @@ import (
 	"time"
 
 	core "dappco.re/go/core"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 // --- helpers to build synthetic JSONL ---
@@ -106,7 +104,7 @@ func writeJSONL(t *testing.T, dir string, name string, lines ...string) string {
 	t.Helper()
 	filePath := path.Join(dir, name)
 	writeResult := hostFS.Write(filePath, core.Concat(core.Join("\n", lines...), "\n"))
-	require.True(t, writeResult.OK)
+	requireTrue(t, writeResult.OK)
 	return filePath
 }
 
@@ -127,21 +125,21 @@ func TestParser_ParseTranscriptMinimalValid_Good(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, sess)
+	requireNoError(t, err)
+	requireNotNil(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) || sess.EndTime.Equal(sess.StartTime))
+	assertEqual(t, "minimal", sess.ID)
+	assertEqual(t, path, sess.Path)
+	assertFalse(t, sess.StartTime.IsZero(), "StartTime should be set")
+	assertFalse(t, sess.EndTime.IsZero(), "EndTime should be set")
+	assertTrue(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)
-	assert.Equal(t, "user", sess.Events[0].Type)
-	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)
+	requireLen(t, sess.Events, 2)
+	assertEqual(t, "user", sess.Events[0].Type)
+	assertEqual(t, "Hello", sess.Events[0].Input)
+	assertEqual(t, "assistant", sess.Events[1].Type)
+	assertEqual(t, "Hi there!", sess.Events[1].Input)
 }
 
 func TestParser_ParseTranscriptToolCalls_Good(t *testing.T) {
@@ -197,7 +195,7 @@ func TestParser_ParseTranscriptToolCalls_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "tools.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	// Count tool_use events
 	var toolEvents []Event
@@ -207,32 +205,32 @@ func TestParser_ParseTranscriptToolCalls_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 7, "should have 7 tool_use events")
+	requireLen(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)
+	assertEqual(t, "Bash", toolEvents[0].Tool)
+	assertContains(t, toolEvents[0].Input, "ls -la")
+	assertContains(t, toolEvents[0].Input, "# list files")
+	assertTrue(t, toolEvents[0].Success)
+	assertEqual(t, time.Second, toolEvents[0].Duration)
 
-	assert.Equal(t, "Read", toolEvents[1].Tool)
-	assert.Equal(t, "/tmp/test.go", toolEvents[1].Input)
+	assertEqual(t, "Read", toolEvents[1].Tool)
+	assertEqual(t, "/tmp/test.go", toolEvents[1].Input)
 
-	assert.Equal(t, "Edit", toolEvents[2].Tool)
-	assert.Equal(t, "/tmp/test.go (edit)", toolEvents[2].Input)
+	assertEqual(t, "Edit", toolEvents[2].Tool)
+	assertEqual(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)
+	assertEqual(t, "Write", toolEvents[3].Tool)
+	assertEqual(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)
+	assertEqual(t, "Grep", toolEvents[4].Tool)
+	assertEqual(t, "/TODO/ in /tmp", toolEvents[4].Input)
 
-	assert.Equal(t, "Glob", toolEvents[5].Tool)
-	assert.Equal(t, "**/*.go", toolEvents[5].Input)
+	assertEqual(t, "Glob", toolEvents[5].Tool)
+	assertEqual(t, "**/*.go", toolEvents[5].Input)
 
-	assert.Equal(t, "Task", toolEvents[6].Tool)
-	assert.Equal(t, "[research] Code analysis", toolEvents[6].Input)
+	assertEqual(t, "Task", toolEvents[6].Tool)
+	assertEqual(t, "[research] Code analysis", toolEvents[6].Input)
 }
 
 func TestParser_ParseTranscriptToolError_Good(t *testing.T) {
@@ -245,7 +243,7 @@ func TestParser_ParseTranscriptToolError_Good(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -254,9 +252,9 @@ func TestParser_ParseTranscriptToolError_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
-	assert.False(t, toolEvents[0].Success)
-	assert.Contains(t, toolEvents[0].ErrorMsg, "No such file or directory")
+	requireLen(t, toolEvents, 1)
+	assertFalse(t, toolEvents[0].Success)
+	assertContains(t, toolEvents[0].ErrorMsg, "No such file or directory")
 }
 
 func TestParser_ParseTranscriptEmptyFile_Bad(t *testing.T) {
@@ -264,13 +262,13 @@ func TestParser_ParseTranscriptEmptyFile_Bad(t *testing.T) {
 	path := writeJSONL(t, dir, "empty.jsonl")
 	// Write a truly empty file
 	writeResult := hostFS.Write(path, "")
-	require.True(t, writeResult.OK)
+	requireTrue(t, writeResult.OK)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	assert.Empty(t, sess.Events)
-	assert.True(t, sess.StartTime.IsZero())
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	assertEmpty(t, sess.Events)
+	assertTrue(t, sess.StartTime.IsZero())
 }
 
 func TestParser_ParseTranscriptMalformedJSON_Bad(t *testing.T) {
@@ -284,13 +282,13 @@ func TestParser_ParseTranscriptMalformedJSON_Bad(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err, "malformed lines should be skipped, not cause an error")
-	require.NotNil(t, sess)
+	requireNoError(t, err, "malformed lines should be skipped, not cause an error")
+	requireNotNil(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)
+	assertLen(t, sess.Events, 2)
+	assertEqual(t, "user", sess.Events[0].Type)
+	assertEqual(t, "assistant", sess.Events[1].Type)
 }
 
 func TestParser_ParseTranscriptTruncatedJSONL_Bad(t *testing.T) {
@@ -303,12 +301,12 @@ func TestParser_ParseTranscriptTruncatedJSONL_Bad(t *testing.T) {
 	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)
+	requireNoError(t, err, "truncated last line should be skipped gracefully")
+	requireNotNil(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)
+	assertLen(t, sess.Events, 1)
+	assertEqual(t, "user", sess.Events[0].Type)
 }
 
 func TestParser_ParseTranscriptLargeSession_Good(t *testing.T) {
@@ -333,7 +331,7 @@ func TestParser_ParseTranscriptLargeSession_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "large.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolCount int
 	for _, e := range sess.Events {
@@ -341,7 +339,7 @@ func TestParser_ParseTranscriptLargeSession_Good(t *testing.T) {
 			toolCount++
 		}
 	}
-	assert.Equal(t, 1100, toolCount, "all 1100 tool events should be parsed")
+	assertEqual(t, 1100, toolCount, "all 1100 tool events should be parsed")
 }
 
 func TestParser_ParseTranscriptNestedToolResults_Good(t *testing.T) {
@@ -379,7 +377,7 @@ func TestParser_ParseTranscriptNestedToolResults_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "nested.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -388,9 +386,9 @@ func TestParser_ParseTranscriptNestedToolResults_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
-	assert.Contains(t, toolEvents[0].Output, "First block")
-	assert.Contains(t, toolEvents[0].Output, "Second block")
+	requireLen(t, toolEvents, 1)
+	assertContains(t, toolEvents[0].Output, "First block")
+	assertContains(t, toolEvents[0].Output, "Second block")
 }
 
 func TestParser_ParseTranscriptNestedMapResult_Good(t *testing.T) {
@@ -424,7 +422,7 @@ func TestParser_ParseTranscriptNestedMapResult_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "map-result.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -433,14 +431,14 @@ func TestParser_ParseTranscriptNestedMapResult_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
-	assert.Contains(t, toolEvents[0].Output, "file contents here")
+	requireLen(t, toolEvents, 1)
+	assertContains(t, toolEvents[0].Output, "file contents here")
 }
 
 func TestParser_ParseTranscriptFileNotFound_Ugly(t *testing.T) {
 	_, _, err := ParseTranscript("/nonexistent/path/session.jsonl")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "open transcript")
+	requireError(t, err)
+	assertContains(t, err.Error(), "open transcript")
 }
 
 func TestParser_ParseTranscriptSessionIDFromFilename_Good(t *testing.T) {
@@ -450,8 +448,8 @@ func TestParser_ParseTranscriptSessionIDFromFilename_Good(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	assert.Equal(t, "abc123def456", sess.ID)
+	requireNoError(t, err)
+	assertEqual(t, "abc123def456", sess.ID)
 }
 
 func TestParser_ParseTranscriptTimestampsTracked_Good(t *testing.T) {
@@ -463,13 +461,13 @@ func TestParser_ParseTranscriptTimestampsTracked_Good(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(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)
+	assertEqual(t, expectedStart, sess.StartTime)
+	assertEqual(t, expectedEnd, sess.EndTime)
 }
 
 func TestParser_ParseTranscriptTextTruncation_Good(t *testing.T) {
@@ -480,12 +478,12 @@ func TestParser_ParseTranscriptTextTruncation_Good(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
-	require.Len(t, sess.Events, 1)
+	requireLen(t, sess.Events, 1)
 	// Input should be truncated to 500 + "..."
-	assert.True(t, len(sess.Events[0].Input) <= 504, "input should be truncated")
-	assert.True(t, core.HasSuffix(sess.Events[0].Input, "..."), "truncated text should end with ...")
+	assertTrue(t, len(sess.Events[0].Input) <= 504, "input should be truncated")
+	assertTrue(t, core.HasSuffix(sess.Events[0].Input, "..."), "truncated text should end with ...")
 }
 
 func TestParser_SessionEventsSeq_Good(t *testing.T) {
@@ -502,7 +500,7 @@ func TestParser_SessionEventsSeq_Good(t *testing.T) {
 		events = append(events, e)
 	}
 
-	assert.Equal(t, sess.Events, events)
+	assertEqual(t, sess.Events, events)
 }
 
 func TestParser_ParseTranscriptMixedContentBlocks_Good(t *testing.T) {
@@ -534,13 +532,13 @@ func TestParser_ParseTranscriptMixedContentBlocks_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "mixed.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	// 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, "tool_use", sess.Events[1].Type)
-	assert.Equal(t, "Read", sess.Events[1].Tool)
+	requireLen(t, sess.Events, 2)
+	assertEqual(t, "assistant", sess.Events[0].Type)
+	assertEqual(t, "tool_use", sess.Events[1].Type)
+	assertEqual(t, "Read", sess.Events[1].Tool)
 }
 
 func TestParser_ParseTranscriptUnmatchedToolResult_Bad(t *testing.T) {
@@ -552,11 +550,11 @@ func TestParser_ParseTranscriptUnmatchedToolResult_Bad(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(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)
+	requireLen(t, sess.Events, 1)
+	assertEqual(t, "user", sess.Events[0].Type)
 }
 
 func TestParser_ParseTranscriptEmptyTimestamp_Bad(t *testing.T) {
@@ -576,10 +574,10 @@ func TestParser_ParseTranscriptEmptyTimestamp_Bad(t *testing.T) {
 	path := writeJSONL(t, dir, "no-ts.jsonl", line)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	// The event should still be parsed, but StartTime remains zero
-	assert.True(t, sess.StartTime.IsZero())
+	assertTrue(t, sess.StartTime.IsZero())
 }
 
 // --- ListSessions tests ---
@@ -588,8 +586,8 @@ func TestParser_ListSessionsEmptyDir_Good(t *testing.T) {
 	dir := t.TempDir()
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	assert.Empty(t, sessions)
+	requireNoError(t, err)
+	assertEmpty(t, sessions)
 }
 
 func TestParser_ListSessionsSingleSession_Good(t *testing.T) {
@@ -600,12 +598,12 @@ func TestParser_ListSessionsSingleSession_Good(t *testing.T) {
 	)
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 1)
+	requireNoError(t, err)
+	requireLen(t, sessions, 1)
 
-	assert.Equal(t, "session-abc", sessions[0].ID)
-	assert.False(t, sessions[0].StartTime.IsZero())
-	assert.False(t, sessions[0].EndTime.IsZero())
+	assertEqual(t, "session-abc", sessions[0].ID)
+	assertFalse(t, sessions[0].StartTime.IsZero())
+	assertFalse(t, sessions[0].EndTime.IsZero())
 }
 
 func TestParser_ListSessionsMultipleSorted_Good(t *testing.T) {
@@ -624,13 +622,13 @@ func TestParser_ListSessionsMultipleSorted_Good(t *testing.T) {
 	)
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 3)
+	requireNoError(t, err)
+	requireLen(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)
+	assertEqual(t, "new", sessions[0].ID)
+	assertEqual(t, "mid", sessions[1].ID)
+	assertEqual(t, "old", sessions[2].ID)
 }
 
 func TestParser_ListSessionsNonJSONLIgnored_Good(t *testing.T) {
@@ -640,14 +638,14 @@ func TestParser_ListSessionsNonJSONLIgnored_Good(t *testing.T) {
 		userTextEntry(ts(0), "real"),
 	)
 	// Write non-JSONL files
-	require.True(t, hostFS.Write(path.Join(dir, "readme.md"), "# Hello").OK)
-	require.True(t, hostFS.Write(path.Join(dir, "notes.txt"), "notes").OK)
-	require.True(t, hostFS.Write(path.Join(dir, "data.json"), "{}").OK)
+	requireTrue(t, hostFS.Write(path.Join(dir, "readme.md"), "# Hello").OK)
+	requireTrue(t, hostFS.Write(path.Join(dir, "notes.txt"), "notes").OK)
+	requireTrue(t, hostFS.Write(path.Join(dir, "data.json"), "{}").OK)
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 1)
-	assert.Equal(t, "real-session", sessions[0].ID)
+	requireNoError(t, err)
+	requireLen(t, sessions, 1)
+	assertEqual(t, "real-session", sessions[0].ID)
 }
 
 func TestParser_ListSessionsSeqMultipleSorted_Good(t *testing.T) {
@@ -663,11 +661,11 @@ func TestParser_ListSessionsSeqMultipleSorted_Good(t *testing.T) {
 		sessions = append(sessions, s)
 	}
 
-	require.Len(t, sessions, 3)
+	requireLen(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)
+	assertEqual(t, "new", sessions[0].ID)
+	assertEqual(t, "mid", sessions[1].ID)
+	assertEqual(t, "old", sessions[2].ID)
 }
 
 func TestParser_ListSessionsMalformedJSONLStillListed_Bad(t *testing.T) {
@@ -680,11 +678,11 @@ func TestParser_ListSessionsMalformedJSONLStillListed_Bad(t *testing.T) {
 	)
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 1)
-	assert.Equal(t, "broken", sessions[0].ID)
+	requireNoError(t, err)
+	requireLen(t, sessions, 1)
+	assertEqual(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")
+	assertFalse(t, sessions[0].StartTime.IsZero(), "should fall back to file modtime")
 }
 
 // --- extractToolInput tests ---
@@ -692,87 +690,87 @@ func TestParser_ListSessionsMalformedJSONLStillListed_Bad(t *testing.T) {
 func TestParser_ExtractToolInputBash_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"command":"go test ./...","description":"run tests","timeout":120}`))
 	result := extractToolInput("Bash", input)
-	assert.Equal(t, "go test ./... # run tests", result)
+	assertEqual(t, "go test ./... # run tests", result)
 }
 
 func TestParser_ExtractToolInputBashNoDescription_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"command":"ls -la"}`))
 	result := extractToolInput("Bash", input)
-	assert.Equal(t, "ls -la", result)
+	assertEqual(t, "ls -la", result)
 }
 
 func TestParser_ExtractToolInputRead_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"file_path":"/Users/test/main.go","offset":10,"limit":50}`))
 	result := extractToolInput("Read", input)
-	assert.Equal(t, "/Users/test/main.go", result)
+	assertEqual(t, "/Users/test/main.go", result)
 }
 
 func TestParser_ExtractToolInputEdit_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"file_path":"/tmp/app.go","old_string":"foo","new_string":"bar"}`))
 	result := extractToolInput("Edit", input)
-	assert.Equal(t, "/tmp/app.go (edit)", result)
+	assertEqual(t, "/tmp/app.go (edit)", result)
 }
 
 func TestParser_ExtractToolInputWrite_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"file_path":"/tmp/out.txt","content":"hello world"}`))
 	result := extractToolInput("Write", input)
-	assert.Equal(t, "/tmp/out.txt (11 bytes)", result)
+	assertEqual(t, "/tmp/out.txt (11 bytes)", result)
 }
 
 func TestParser_ExtractToolInputGrep_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"pattern":"TODO","path":"/src"}`))
 	result := extractToolInput("Grep", input)
-	assert.Equal(t, "/TODO/ in /src", result)
+	assertEqual(t, "/TODO/ in /src", result)
 }
 
 func TestParser_ExtractToolInputGrepNoPath_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"pattern":"FIXME"}`))
 	result := extractToolInput("Grep", input)
-	assert.Equal(t, "/FIXME/ in .", result)
+	assertEqual(t, "/FIXME/ in .", result)
 }
 
 func TestParser_ExtractToolInputGlob_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"pattern":"**/*.go","path":"/src"}`))
 	result := extractToolInput("Glob", input)
-	assert.Equal(t, "**/*.go", result)
+	assertEqual(t, "**/*.go", result)
 }
 
 func TestParser_ExtractToolInputTask_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"prompt":"Analyse the codebase","description":"Code review","subagent_type":"research"}`))
 	result := extractToolInput("Task", input)
-	assert.Equal(t, "[research] Code review", result)
+	assertEqual(t, "[research] Code review", result)
 }
 
 func TestParser_ExtractToolInputTaskNoDescription_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"prompt":"Short prompt","subagent_type":"codegen"}`))
 	result := extractToolInput("Task", input)
-	assert.Equal(t, "[codegen] Short prompt", result)
+	assertEqual(t, "[codegen] Short prompt", result)
 }
 
 func TestParser_ExtractToolInputUnknownTool_Good(t *testing.T) {
 	input := rawJSON([]byte(`{"alpha":"one","beta":"two"}`))
 	result := extractToolInput("CustomTool", input)
 	// Fallback: sorted keys
-	assert.Equal(t, "alpha, beta", result)
+	assertEqual(t, "alpha, beta", result)
 }
 
 func TestParser_ExtractToolInputNilInput_Bad(t *testing.T) {
 	result := extractToolInput("Bash", nil)
-	assert.Equal(t, "", result)
+	assertEqual(t, "", result)
 }
 
 func TestParser_ExtractToolInputInvalidJSON_Bad(t *testing.T) {
 	input := rawJSON([]byte(`{broken`))
 	result := extractToolInput("Bash", input)
 	// All unmarshals fail, including the fallback map unmarshal
-	assert.Equal(t, "", result)
+	assertEqual(t, "", result)
 }
 
 // --- extractResultContent tests ---
 
 func TestParser_ExtractResultContentString_Good(t *testing.T) {
 	result := extractResultContent("simple string")
-	assert.Equal(t, "simple string", result)
+	assertEqual(t, "simple string", result)
 }
 
 func TestParser_ExtractResultContentArray_Good(t *testing.T) {
@@ -781,52 +779,52 @@ func TestParser_ExtractResultContentArray_Good(t *testing.T) {
 		map[string]any{"type": "text", "text": "line two"},
 	}
 	result := extractResultContent(content)
-	assert.Equal(t, "line one\nline two", result)
+	assertEqual(t, "line one\nline two", result)
 }
 
 func TestParser_ExtractResultContentMap_Good(t *testing.T) {
 	content := map[string]any{"text": "from map"}
 	result := extractResultContent(content)
-	assert.Equal(t, "from map", result)
+	assertEqual(t, "from map", result)
 }
 
 func TestParser_ExtractResultContentOther_Bad(t *testing.T) {
 	result := extractResultContent(42)
-	assert.Equal(t, "42", result)
+	assertEqual(t, "42", result)
 }
 
 // --- truncate tests ---
 
 func TestParser_TruncateShort_Good(t *testing.T) {
-	assert.Equal(t, "hello", truncate("hello", 10))
+	assertEqual(t, "hello", truncate("hello", 10))
 }
 
 func TestParser_TruncateExact_Good(t *testing.T) {
-	assert.Equal(t, "hello", truncate("hello", 5))
+	assertEqual(t, "hello", truncate("hello", 5))
 }
 
 func TestParser_TruncateLong_Good(t *testing.T) {
 	result := truncate("hello world", 5)
-	assert.Equal(t, "hello...", result)
+	assertEqual(t, "hello...", result)
 }
 
 func TestParser_TruncateEmpty_Good(t *testing.T) {
-	assert.Equal(t, "", truncate("", 10))
+	assertEqual(t, "", truncate("", 10))
 }
 
 // --- helper function tests ---
 
 func TestParser_ShortIDTruncatesAndPreservesLength_Good(t *testing.T) {
-	assert.Equal(t, "abcdefgh", shortID("abcdefghijklmnop"))
-	assert.Equal(t, "short", shortID("short"))
-	assert.Equal(t, "12345678", shortID("12345678"))
+	assertEqual(t, "abcdefgh", shortID("abcdefghijklmnop"))
+	assertEqual(t, "short", shortID("short"))
+	assertEqual(t, "12345678", shortID("12345678"))
 }
 
 func TestParser_FormatDurationCommonDurations_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))
+	assertEqual(t, "500ms", formatDuration(500*time.Millisecond))
+	assertEqual(t, "1.5s", formatDuration(1500*time.Millisecond))
+	assertEqual(t, "2m30s", formatDuration(2*time.Minute+30*time.Second))
+	assertEqual(t, "1h5m", formatDuration(1*time.Hour+5*time.Minute))
 }
 
 // --- ParseStats tests ---
@@ -843,13 +841,13 @@ func TestParser_ParseStatsCleanJSONL_Good(t *testing.T) {
 	)
 
 	_, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 4, stats.TotalLines)
-	assert.Equal(t, 0, stats.SkippedLines)
-	assert.Equal(t, 0, stats.OrphanedToolCalls)
-	assert.Empty(t, stats.Warnings)
+	assertEqual(t, 4, stats.TotalLines)
+	assertEqual(t, 0, stats.SkippedLines)
+	assertEqual(t, 0, stats.OrphanedToolCalls)
+	assertEmpty(t, stats.Warnings)
 }
 
 func TestParser_ParseStatsMalformedLines_Good(t *testing.T) {
@@ -863,16 +861,16 @@ func TestParser_ParseStatsMalformedLines_Good(t *testing.T) {
 	)
 
 	_, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 5, stats.TotalLines)
-	assert.Equal(t, 3, stats.SkippedLines)
-	assert.Len(t, stats.Warnings, 3)
+	assertEqual(t, 5, stats.TotalLines)
+	assertEqual(t, 3, stats.SkippedLines)
+	assertLen(t, stats.Warnings, 3)
 
 	// Each warning should contain line number and preview
 	for _, w := range stats.Warnings {
-		assert.Contains(t, w, "skipped (bad JSON)")
+		assertContains(t, w, "skipped (bad JSON)")
 	}
 }
 
@@ -890,10 +888,10 @@ func TestParser_ParseStatsOrphanedToolCalls_Good(t *testing.T) {
 	)
 
 	_, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 2, stats.OrphanedToolCalls)
+	assertEqual(t, 2, stats.OrphanedToolCalls)
 
 	// Warnings should mention orphaned tool IDs
 	var orphanWarnings int
@@ -902,7 +900,7 @@ func TestParser_ParseStatsOrphanedToolCalls_Good(t *testing.T) {
 			orphanWarnings++
 		}
 	}
-	assert.Equal(t, 2, orphanWarnings)
+	assertEqual(t, 2, orphanWarnings)
 }
 
 func TestParser_ParseStatsTruncatedFinalLine_Good(t *testing.T) {
@@ -912,13 +910,13 @@ func TestParser_ParseStatsTruncatedFinalLine_Good(t *testing.T) {
 
 	// Write without trailing newline after truncated line
 	path := path.Join(dir, "truncfinal.jsonl")
-	require.True(t, hostFS.Write(path, validLine+"\n"+truncatedLine+"\n").OK)
+	requireTrue(t, hostFS.Write(path, validLine+"\n"+truncatedLine+"\n").OK)
 
 	_, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 1, stats.SkippedLines)
+	assertEqual(t, 1, stats.SkippedLines)
 
 	// Should detect truncated final line
 	var foundTruncated bool
@@ -927,7 +925,7 @@ func TestParser_ParseStatsTruncatedFinalLine_Good(t *testing.T) {
 			foundTruncated = true
 		}
 	}
-	assert.True(t, foundTruncated, "should detect truncated final line")
+	assertTrue(t, foundTruncated, "should detect truncated final line")
 }
 
 func TestParser_ParseStatsFileEndingMidJSON_Good(t *testing.T) {
@@ -936,14 +934,14 @@ func TestParser_ParseStatsFileEndingMidJSON_Good(t *testing.T) {
 	midJSON := `{"type":"assistant","timestamp":"2026-02-20T10:00:01Z","sessionId":"test","message":{"role":"assi`
 
 	path := path.Join(dir, "midjson.jsonl")
-	require.True(t, hostFS.Write(path, validLine+"\n"+midJSON+"\n").OK)
+	requireTrue(t, hostFS.Write(path, validLine+"\n"+midJSON+"\n").OK)
 
 	sess, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 1, stats.SkippedLines)
+	assertEqual(t, 1, stats.SkippedLines)
 
 	var foundTruncated bool
 	for _, w := range stats.Warnings {
@@ -951,7 +949,7 @@ func TestParser_ParseStatsFileEndingMidJSON_Good(t *testing.T) {
 			foundTruncated = true
 		}
 	}
-	assert.True(t, foundTruncated)
+	assertTrue(t, foundTruncated)
 }
 
 func TestParser_ParseStatsCompleteFileNoTrailingNewline_Good(t *testing.T) {
@@ -960,16 +958,16 @@ func TestParser_ParseStatsCompleteFileNoTrailingNewline_Good(t *testing.T) {
 
 	// Write without trailing newline — should still parse fine
 	path := path.Join(dir, "nonewline.jsonl")
-	require.True(t, hostFS.Write(path, line).OK)
+	requireTrue(t, hostFS.Write(path, line).OK)
 
 	sess, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, 0, stats.SkippedLines)
-	assert.Equal(t, 0, stats.OrphanedToolCalls)
-	assert.Len(t, sess.Events, 1)
+	assertEqual(t, 0, stats.SkippedLines)
+	assertEqual(t, 0, stats.OrphanedToolCalls)
+	assertLen(t, sess.Events, 1)
 
 	// No truncation warning since the line parsed successfully
 	var foundTruncated bool
@@ -978,7 +976,7 @@ func TestParser_ParseStatsCompleteFileNoTrailingNewline_Good(t *testing.T) {
 			foundTruncated = true
 		}
 	}
-	assert.False(t, foundTruncated)
+	assertFalse(t, foundTruncated)
 }
 
 func TestParser_ParseStatsWarningPreviewTruncated_Good(t *testing.T) {
@@ -991,13 +989,13 @@ func TestParser_ParseStatsWarningPreviewTruncated_Good(t *testing.T) {
 	)
 
 	_, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
-	require.Len(t, stats.Warnings, 1) // 1 skipped line (last line is valid, no truncation)
+	requireLen(t, stats.Warnings, 1) // 1 skipped line (last line is valid, no truncation)
 	// The preview in the warning should be at most ~100 chars of the bad line
-	assert.True(t, len(stats.Warnings[0]) < 200,
+	assertTrue(t, len(stats.Warnings[0]) < 200,
 		"warning preview should be truncated for long lines")
-	assert.Contains(t, stats.Warnings[0], "line 1:")
+	assertContains(t, stats.Warnings[0], "line 1:")
 }
 
 // --- ParseTranscriptReader (streaming) tests ---
@@ -1011,17 +1009,17 @@ func TestParser_ParseTranscriptReaderMinimalValid_Good(t *testing.T) {
 	reader := core.NewReader(data)
 
 	sess, stats, err := ParseTranscriptReader(reader, "stream-session")
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	require.NotNil(t, stats)
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	requireNotNil(t, stats)
 
-	assert.Equal(t, "stream-session", sess.ID)
-	assert.Empty(t, sess.Path, "reader-based parse should have empty path")
-	assert.Len(t, sess.Events, 2)
-	assert.Equal(t, "hello", sess.Events[0].Input)
-	assert.Equal(t, "world", sess.Events[1].Input)
-	assert.Equal(t, 2, stats.TotalLines)
-	assert.Equal(t, 0, stats.SkippedLines)
+	assertEqual(t, "stream-session", sess.ID)
+	assertEmpty(t, sess.Path, "reader-based parse should have empty path")
+	assertLen(t, sess.Events, 2)
+	assertEqual(t, "hello", sess.Events[0].Input)
+	assertEqual(t, "world", sess.Events[1].Input)
+	assertEqual(t, 2, stats.TotalLines)
+	assertEqual(t, 0, stats.SkippedLines)
 }
 
 func TestParser_ParseTranscriptReaderBytesBuffer_Good(t *testing.T) {
@@ -1036,20 +1034,20 @@ func TestParser_ParseTranscriptReaderBytesBuffer_Good(t *testing.T) {
 	buf := bytes.NewBufferString(data)
 
 	sess, _, err := ParseTranscriptReader(buf, "buf-session")
-	require.NoError(t, err)
-	require.Len(t, sess.Events, 1)
-	assert.Equal(t, "Bash", sess.Events[0].Tool)
-	assert.True(t, sess.Events[0].Success)
+	requireNoError(t, err)
+	requireLen(t, sess.Events, 1)
+	assertEqual(t, "Bash", sess.Events[0].Tool)
+	assertTrue(t, sess.Events[0].Success)
 }
 
 func TestParser_ParseTranscriptReaderEmptyReader_Good(t *testing.T) {
 	reader := core.NewReader("")
 
 	sess, stats, err := ParseTranscriptReader(reader, "empty")
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	assert.Empty(t, sess.Events)
-	assert.Equal(t, 0, stats.TotalLines)
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	assertEmpty(t, sess.Events)
+	assertEqual(t, 0, stats.TotalLines)
 }
 
 func TestParser_ParseTranscriptReaderLargeLines_Good(t *testing.T) {
@@ -1059,10 +1057,10 @@ func TestParser_ParseTranscriptReaderLargeLines_Good(t *testing.T) {
 	reader := core.NewReader(data)
 
 	sess, _, err := ParseTranscriptReader(reader, "big-session")
-	require.NoError(t, err)
-	require.Len(t, sess.Events, 1)
+	requireNoError(t, err)
+	requireLen(t, sess.Events, 1)
 	// Input gets truncated to 500 chars by the truncate function.
-	assert.Len(t, sess.Events[0].Input, 503) // 500 + "..."
+	assertLen(t, sess.Events[0].Input, 503) // 500 + "..."
 }
 
 func TestParser_ParseTranscriptReaderMalformedWithStats_Good(t *testing.T) {
@@ -1075,10 +1073,10 @@ func TestParser_ParseTranscriptReaderMalformedWithStats_Good(t *testing.T) {
 	reader := core.NewReader(data)
 
 	sess, stats, err := ParseTranscriptReader(reader, "mixed")
-	require.NoError(t, err)
-	assert.Len(t, sess.Events, 1)
-	assert.Equal(t, 3, stats.TotalLines)
-	assert.Equal(t, 2, stats.SkippedLines)
+	requireNoError(t, err)
+	assertLen(t, sess.Events, 1)
+	assertEqual(t, 3, stats.TotalLines)
+	assertEqual(t, 2, stats.SkippedLines)
 }
 
 func TestParser_ParseTranscriptReaderOrphanedTools_Good(t *testing.T) {
@@ -1092,8 +1090,8 @@ func TestParser_ParseTranscriptReaderOrphanedTools_Good(t *testing.T) {
 	reader := core.NewReader(data)
 
 	_, stats, err := ParseTranscriptReader(reader, "orphan-reader")
-	require.NoError(t, err)
-	assert.Equal(t, 1, stats.OrphanedToolCalls)
+	requireNoError(t, err)
+	assertEqual(t, 1, stats.OrphanedToolCalls)
 }
 
 // --- Custom MCP tool tests ---
@@ -1112,7 +1110,7 @@ func TestParser_ParseTranscriptCustomMCPTool_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "mcp_tool.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -1121,13 +1119,13 @@ func TestParser_ParseTranscriptCustomMCPTool_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
-	assert.Equal(t, "mcp__forge__create_issue", toolEvents[0].Tool)
+	requireLen(t, toolEvents, 1)
+	assertEqual(t, "mcp__forge__create_issue", toolEvents[0].Tool)
 	// Fallback should show sorted keys.
-	assert.Contains(t, toolEvents[0].Input, "body")
-	assert.Contains(t, toolEvents[0].Input, "repo")
-	assert.Contains(t, toolEvents[0].Input, "title")
-	assert.True(t, toolEvents[0].Success)
+	assertContains(t, toolEvents[0].Input, "body")
+	assertContains(t, toolEvents[0].Input, "repo")
+	assertContains(t, toolEvents[0].Input, "title")
+	assertTrue(t, toolEvents[0].Success)
 }
 
 func TestParser_ParseTranscriptCustomMCPToolNestedInput_Good(t *testing.T) {
@@ -1143,7 +1141,7 @@ func TestParser_ParseTranscriptCustomMCPToolNestedInput_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "mcp_nested.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -1152,9 +1150,9 @@ func TestParser_ParseTranscriptCustomMCPToolNestedInput_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
-	assert.Contains(t, toolEvents[0].Input, "params")
-	assert.Contains(t, toolEvents[0].Input, "query")
+	requireLen(t, toolEvents, 1)
+	assertContains(t, toolEvents[0].Input, "params")
+	assertContains(t, toolEvents[0].Input, "query")
 }
 
 func TestParser_ParseTranscriptUnknownToolEmptyInput_Good(t *testing.T) {
@@ -1167,7 +1165,7 @@ func TestParser_ParseTranscriptUnknownToolEmptyInput_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "empty_input.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	var toolEvents []Event
 	for _, e := range sess.Events {
@@ -1176,9 +1174,9 @@ func TestParser_ParseTranscriptUnknownToolEmptyInput_Good(t *testing.T) {
 		}
 	}
 
-	require.Len(t, toolEvents, 1)
+	requireLen(t, toolEvents, 1)
 	// Empty object should produce empty string from fallback.
-	assert.Equal(t, "", toolEvents[0].Input)
+	assertEqual(t, "", toolEvents[0].Input)
 }
 
 // --- Edge case error recovery tests ---
@@ -1195,7 +1193,7 @@ func TestParser_ParseTranscriptBinaryGarbage_Ugly(t *testing.T) {
 	path := writeJSONL(t, dir, "binary.jsonl", lines...)
 
 	sess, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 
 	// Only the valid line should produce an event.
 	var userEvents []Event
@@ -1204,9 +1202,9 @@ func TestParser_ParseTranscriptBinaryGarbage_Ugly(t *testing.T) {
 			userEvents = append(userEvents, e)
 		}
 	}
-	require.Len(t, userEvents, 1)
-	assert.Equal(t, "survived", userEvents[0].Input)
-	assert.Equal(t, 2, stats.SkippedLines)
+	requireLen(t, userEvents, 1)
+	assertEqual(t, "survived", userEvents[0].Input)
+	assertEqual(t, 2, stats.SkippedLines)
 }
 
 func TestParser_ParseTranscriptNullBytes_Ugly(t *testing.T) {
@@ -1219,8 +1217,8 @@ func TestParser_ParseTranscriptNullBytes_Ugly(t *testing.T) {
 	path := writeJSONL(t, dir, "null_bytes.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	assert.Len(t, sess.Events, 1)
+	requireNoError(t, err)
+	assertLen(t, sess.Events, 1)
 }
 
 func TestParser_ParseTranscriptVeryLongLine_Ugly(t *testing.T) {
@@ -1233,8 +1231,8 @@ func TestParser_ParseTranscriptVeryLongLine_Ugly(t *testing.T) {
 	)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	require.Len(t, sess.Events, 1)
+	requireNoError(t, err)
+	requireLen(t, sess.Events, 1)
 }
 
 func TestParser_ParseTranscriptMalformedMessageJSON_Bad(t *testing.T) {
@@ -1247,10 +1245,10 @@ func TestParser_ParseTranscriptMalformedMessageJSON_Bad(t *testing.T) {
 	path := writeJSONL(t, dir, "bad_msg.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 	// First line's message is a string, not object — should be skipped.
-	assert.Len(t, sess.Events, 1)
-	assert.Equal(t, "ok", sess.Events[0].Input)
+	assertLen(t, sess.Events, 1)
+	assertEqual(t, "ok", sess.Events[0].Input)
 }
 
 func TestParser_ParseTranscriptMalformedContentBlock_Bad(t *testing.T) {
@@ -1263,9 +1261,9 @@ func TestParser_ParseTranscriptMalformedContentBlock_Bad(t *testing.T) {
 	path := writeJSONL(t, dir, "bad_block.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	assert.Len(t, sess.Events, 1)
-	assert.Equal(t, "still ok", sess.Events[0].Input)
+	requireNoError(t, err)
+	assertLen(t, sess.Events, 1)
+	assertEqual(t, "still ok", sess.Events[0].Input)
 }
 
 func TestParser_ParseTranscriptTruncatedMissingBrace_Good(t *testing.T) {
@@ -1279,11 +1277,11 @@ func TestParser_ParseTranscriptTruncatedMissingBrace_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "trunc_brace.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
+	requireNoError(t, err)
 	// Only the two complete lines should produce events.
-	assert.Len(t, sess.Events, 2)
-	assert.Equal(t, "valid", sess.Events[0].Input)
-	assert.Equal(t, "also valid", sess.Events[1].Input)
+	assertLen(t, sess.Events, 2)
+	assertEqual(t, "valid", sess.Events[0].Input)
+	assertEqual(t, "also valid", sess.Events[1].Input)
 }
 
 func TestParser_ParseTranscriptTruncatedMidKey_Good(t *testing.T) {
@@ -1296,9 +1294,9 @@ func TestParser_ParseTranscriptTruncatedMidKey_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "trunc_midkey.jsonl", lines...)
 
 	sess, _, err := ParseTranscript(path)
-	require.NoError(t, err)
-	assert.Len(t, sess.Events, 1)
-	assert.Equal(t, "first", sess.Events[0].Input)
+	requireNoError(t, err)
+	assertLen(t, sess.Events, 1)
+	assertEqual(t, "first", sess.Events[0].Input)
 }
 
 func TestParser_ParseTranscriptAllBadLines_Good(t *testing.T) {
@@ -1312,10 +1310,10 @@ func TestParser_ParseTranscriptAllBadLines_Good(t *testing.T) {
 	path := writeJSONL(t, dir, "all_bad.jsonl", lines...)
 
 	sess, stats, err := ParseTranscript(path)
-	require.NoError(t, err)
-	assert.Empty(t, sess.Events)
-	assert.True(t, sess.StartTime.IsZero())
-	assert.Equal(t, 3, stats.SkippedLines)
+	requireNoError(t, err)
+	assertEmpty(t, sess.Events)
+	assertTrue(t, sess.StartTime.IsZero())
+	assertEqual(t, 3, stats.SkippedLines)
 }
 
 // --- ListSessions with truncated files ---
@@ -1331,7 +1329,7 @@ func TestParser_PruneSessionsDeletesOldFiles_Good(t *testing.T) {
 	)
 	// Backdate the file's mtime by 2 hours.
 	oldTime := time.Now().Add(-2 * time.Hour)
-	require.NoError(t, setFileTimes(path, oldTime, oldTime))
+	requireNoError(t, setFileTimes(path, oldTime, oldTime))
 
 	// Create a recent session file.
 	writeJSONL(t, dir, "new-session.jsonl",
@@ -1340,14 +1338,14 @@ func TestParser_PruneSessionsDeletesOldFiles_Good(t *testing.T) {
 
 	// Prune sessions older than 1 hour.
 	deleted, err := PruneSessions(dir, 1*time.Hour)
-	require.NoError(t, err)
-	assert.Equal(t, 1, deleted)
+	requireNoError(t, err)
+	assertEqual(t, 1, deleted)
 
 	// Verify only the new file remains.
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 1)
-	assert.Equal(t, "new-session", sessions[0].ID)
+	requireNoError(t, err)
+	requireLen(t, sessions, 1)
+	assertEqual(t, "new-session", sessions[0].ID)
 }
 
 func TestParser_PruneSessionsNothingToDelete_Good(t *testing.T) {
@@ -1358,16 +1356,16 @@ func TestParser_PruneSessionsNothingToDelete_Good(t *testing.T) {
 	)
 
 	deleted, err := PruneSessions(dir, 24*time.Hour)
-	require.NoError(t, err)
-	assert.Equal(t, 0, deleted)
+	requireNoError(t, err)
+	assertEqual(t, 0, deleted)
 }
 
 func TestParser_PruneSessionsEmptyDir_Good(t *testing.T) {
 	dir := t.TempDir()
 
 	deleted, err := PruneSessions(dir, 1*time.Hour)
-	require.NoError(t, err)
-	assert.Equal(t, 0, deleted)
+	requireNoError(t, err)
+	assertEqual(t, 0, deleted)
 }
 
 // --- IsExpired tests ---
@@ -1376,19 +1374,19 @@ func TestParser_IsExpiredRecentSession_Good(t *testing.T) {
 	sess := &Session{
 		EndTime: time.Now().Add(-5 * time.Minute),
 	}
-	assert.False(t, sess.IsExpired(1*time.Hour))
+	assertFalse(t, sess.IsExpired(1*time.Hour))
 }
 
 func TestParser_IsExpiredOldSession_Good(t *testing.T) {
 	sess := &Session{
 		EndTime: time.Now().Add(-2 * time.Hour),
 	}
-	assert.True(t, sess.IsExpired(1*time.Hour))
+	assertTrue(t, sess.IsExpired(1*time.Hour))
 }
 
 func TestParser_IsExpiredZeroEndTime_Bad(t *testing.T) {
 	sess := &Session{}
-	assert.False(t, sess.IsExpired(1*time.Hour))
+	assertFalse(t, sess.IsExpired(1*time.Hour))
 }
 
 // --- FetchSession tests ---
@@ -1400,43 +1398,43 @@ func TestParser_FetchSessionValidID_Good(t *testing.T) {
 	)
 
 	sess, stats, err := FetchSession(dir, "abc123")
-	require.NoError(t, err)
-	require.NotNil(t, sess)
-	require.NotNil(t, stats)
-	assert.Equal(t, "abc123", sess.ID)
-	assert.Len(t, sess.Events, 1)
+	requireNoError(t, err)
+	requireNotNil(t, sess)
+	requireNotNil(t, stats)
+	assertEqual(t, "abc123", sess.ID)
+	assertLen(t, sess.Events, 1)
 }
 
 func TestParser_FetchSessionPathTraversal_Ugly(t *testing.T) {
 	dir := t.TempDir()
 
 	_, _, err := FetchSession(dir, "../etc/passwd")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid session id")
+	requireError(t, err)
+	assertContains(t, err.Error(), "invalid session id")
 }
 
 func TestParser_FetchSessionBackslashTraversal_Ugly(t *testing.T) {
 	dir := t.TempDir()
 
 	_, _, err := FetchSession(dir, `foo\bar`)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid session id")
+	requireError(t, err)
+	assertContains(t, err.Error(), "invalid session id")
 }
 
 func TestParser_FetchSessionForwardSlash_Ugly(t *testing.T) {
 	dir := t.TempDir()
 
 	_, _, err := FetchSession(dir, "foo/bar")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid session id")
+	requireError(t, err)
+	assertContains(t, err.Error(), "invalid session id")
 }
 
 func TestParser_FetchSessionNotFound_Bad(t *testing.T) {
 	dir := t.TempDir()
 
 	_, _, err := FetchSession(dir, "nonexistent")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "open transcript")
+	requireError(t, err)
+	assertContains(t, err.Error(), "open transcript")
 }
 
 // --- ListSessions with truncated files ---
@@ -1453,12 +1451,12 @@ func TestParser_ListSessionsTruncatedFile_Good(t *testing.T) {
 	writeJSONL(t, dir, "partial.jsonl", lines...)
 
 	sessions, err := ListSessions(dir)
-	require.NoError(t, err)
-	require.Len(t, sessions, 1)
-	assert.False(t, sessions[0].StartTime.IsZero())
-	assert.False(t, sessions[0].EndTime.IsZero())
+	requireNoError(t, err)
+	requireLen(t, sessions, 1)
+	assertFalse(t, sessions[0].StartTime.IsZero())
+	assertFalse(t, sessions[0].EndTime.IsZero())
 	// End time should reflect the last valid timestamp.
-	assert.True(t, sessions[0].EndTime.After(sessions[0].StartTime))
+	assertTrue(t, sessions[0].EndTime.After(sessions[0].StartTime))
 }
 
 // --- PruneSessions tests ---
diff --git a/search.go b/search.go
index 78d6231..151b437 100644
--- a/search.go
+++ b/search.go
@@ -2,10 +2,10 @@
 package session
 
 import (
-	"iter"
-	"path"
-	"slices"
-	"time"
+	"iter"   // Note: intrinsic — public lazy sequence API for search results; no core equivalent
+	"path"   // Note: intrinsic — slash-separated transcript glob path construction; no core equivalent
+	"slices" // Note: intrinsic — slices.Collect materialises search iterator results; no core equivalent
+	"time"   // Note: intrinsic — search result timestamps mirror parsed transcript event times; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/search_test.go b/search_test.go
index 8d8fd3c..bb7487e 100644
--- a/search_test.go
+++ b/search_test.go
@@ -4,17 +4,14 @@ package session
 import (
 	"path"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestSearch_SearchEmptyDir_Good(t *testing.T) {
 	dir := t.TempDir()
 
 	results, err := Search(dir, "anything")
-	require.NoError(t, err)
-	assert.Empty(t, results)
+	requireNoError(t, err)
+	assertEmpty(t, results)
 }
 
 func TestSearch_SearchNoMatches_Good(t *testing.T) {
@@ -27,8 +24,8 @@ func TestSearch_SearchNoMatches_Good(t *testing.T) {
 	)
 
 	results, err := Search(dir, "nonexistent-query")
-	require.NoError(t, err)
-	assert.Empty(t, results)
+	requireNoError(t, err)
+	assertEmpty(t, results)
 }
 
 func TestSearch_SearchSingleMatch_Good(t *testing.T) {
@@ -41,12 +38,12 @@ func TestSearch_SearchSingleMatch_Good(t *testing.T) {
 	)
 
 	results, err := Search(dir, "go test")
-	require.NoError(t, err)
-	require.Len(t, results, 1)
+	requireNoError(t, err)
+	requireLen(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")
+	assertEqual(t, "session", results[0].SessionID)
+	assertEqual(t, "Bash", results[0].Tool)
+	assertContains(t, results[0].Match, "go test")
 }
 
 func TestSearch_SearchSeqSingleMatch_Good(t *testing.T) {
@@ -63,9 +60,9 @@ func TestSearch_SearchSeqSingleMatch_Good(t *testing.T) {
 		results = append(results, r)
 	}
 
-	require.Len(t, results, 1)
-	assert.Equal(t, "session", results[0].SessionID)
-	assert.Equal(t, "Bash", results[0].Tool)
+	requireLen(t, results, 1)
+	assertEqual(t, "session", results[0].SessionID)
+	assertEqual(t, "Bash", results[0].Tool)
 }
 
 func TestSearch_SearchMultipleMatches_Good(t *testing.T) {
@@ -88,8 +85,8 @@ func TestSearch_SearchMultipleMatches_Good(t *testing.T) {
 	)
 
 	results, err := Search(dir, "go test")
-	require.NoError(t, err)
-	assert.Len(t, results, 3, "should find matches across both sessions")
+	requireNoError(t, err)
+	assertLen(t, results, 3, "should find matches across both sessions")
 }
 
 func TestSearch_SearchCaseInsensitive_Good(t *testing.T) {
@@ -102,8 +99,8 @@ func TestSearch_SearchCaseInsensitive_Good(t *testing.T) {
 	)
 
 	results, err := Search(dir, "go test")
-	require.NoError(t, err)
-	assert.Len(t, results, 1, "search should be case-insensitive")
+	requireNoError(t, err)
+	assertLen(t, results, 1, "search should be case-insensitive")
 }
 
 func TestSearch_SearchMatchesInOutput_Good(t *testing.T) {
@@ -116,10 +113,10 @@ func TestSearch_SearchMatchesInOutput_Good(t *testing.T) {
 	)
 
 	results, err := Search(dir, "connection refused")
-	require.NoError(t, err)
-	require.Len(t, results, 1, "should match against output text")
+	requireNoError(t, err)
+	requireLen(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")
+	assertContains(t, results[0].Match, "cat log.txt")
 }
 
 func TestSearch_SearchSkipsNonToolEvents_Good(t *testing.T) {
@@ -131,18 +128,18 @@ func TestSearch_SearchSkipsNonToolEvents_Good(t *testing.T) {
 
 	// "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")
+	requireNoError(t, err)
+	assertEmpty(t, results, "should only match tool_use events, not user/assistant text")
 }
 
 func TestSearch_SearchNonJSONLIgnored_Good(t *testing.T) {
 	dir := t.TempDir()
 	writeResult := hostFS.Write(path.Join(dir, "readme.md"), "go test")
-	require.True(t, writeResult.OK)
+	requireTrue(t, writeResult.OK)
 
 	results, err := Search(dir, "go test")
-	require.NoError(t, err)
-	assert.Empty(t, results, "non-JSONL files should be ignored")
+	requireNoError(t, err)
+	assertEmpty(t, results, "non-JSONL files should be ignored")
 }
 
 func TestSearch_SearchMalformedSessionSkipped_Bad(t *testing.T) {
@@ -160,6 +157,6 @@ func TestSearch_SearchMalformedSessionSkipped_Bad(t *testing.T) {
 	)
 
 	results, err := Search(dir, "go test")
-	require.NoError(t, err)
-	assert.Len(t, results, 1, "should still find matches in valid sessions")
+	requireNoError(t, err)
+	assertLen(t, results, 1, "should still find matches in valid sessions")
 }
diff --git a/test_helpers_test.go b/test_helpers_test.go
new file mode 100644
index 0000000..40f0170
--- /dev/null
+++ b/test_helpers_test.go
@@ -0,0 +1,179 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+package session
+
+import (
+	"reflect"
+	"testing"
+
+	core "dappco.re/go/core"
+)
+
+func testContext(msgAndArgs []any) string {
+	if len(msgAndArgs) == 0 {
+		return ""
+	}
+	return core.Sprintf("%v: ", msgAndArgs[0])
+}
+
+func isNil(v any) bool {
+	if v == nil {
+		return true
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func isEmpty(v any) bool {
+	if isNil(v) {
+		return true
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String:
+		return rv.Len() == 0
+	default:
+		return rv.IsZero()
+	}
+}
+
+func valueLen(v any) (int, bool) {
+	if v == nil {
+		return 0, true
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String:
+		return rv.Len(), true
+	default:
+		return 0, false
+	}
+}
+
+func requireNoError(t *testing.T, err error, msgAndArgs ...any) {
+	t.Helper()
+	if err != nil {
+		t.Fatalf("%sunexpected error: %v", testContext(msgAndArgs), err)
+	}
+}
+
+func requireError(t *testing.T, err error, msgAndArgs ...any) {
+	t.Helper()
+	if err == nil {
+		t.Fatalf("%sexpected error, got nil", testContext(msgAndArgs))
+	}
+}
+
+func requireEqual(t *testing.T, want, got any, msgAndArgs ...any) {
+	t.Helper()
+	if !reflect.DeepEqual(want, got) {
+		t.Fatalf("%swant %v, got %v", testContext(msgAndArgs), want, got)
+	}
+}
+
+func requireTrue(t *testing.T, cond bool, msgAndArgs ...any) {
+	t.Helper()
+	if !cond {
+		t.Fatalf("%sexpected true", testContext(msgAndArgs))
+	}
+}
+
+func requireNotNil(t *testing.T, v any, msgAndArgs ...any) {
+	t.Helper()
+	if isNil(v) {
+		t.Fatalf("%sexpected non-nil", testContext(msgAndArgs))
+	}
+}
+
+func requireLen(t *testing.T, v any, want int, msgAndArgs ...any) {
+	t.Helper()
+	got, ok := valueLen(v)
+	if !ok {
+		t.Fatalf("%sexpected value with length, got %T", testContext(msgAndArgs), v)
+	}
+	if want != got {
+		t.Fatalf("%swant length %v, got %v", testContext(msgAndArgs), want, got)
+	}
+}
+
+func assertEqual(t *testing.T, want, got any, msgAndArgs ...any) {
+	t.Helper()
+	if !reflect.DeepEqual(want, got) {
+		t.Fatalf("%swant %v, got %v", testContext(msgAndArgs), want, got)
+	}
+}
+
+func assertTrue(t *testing.T, cond bool, msgAndArgs ...any) {
+	t.Helper()
+	if !cond {
+		t.Fatalf("%sexpected true", testContext(msgAndArgs))
+	}
+}
+
+func assertFalse(t *testing.T, cond bool, msgAndArgs ...any) {
+	t.Helper()
+	if cond {
+		t.Fatalf("%sexpected false", testContext(msgAndArgs))
+	}
+}
+
+func assertNil(t *testing.T, v any, msgAndArgs ...any) {
+	t.Helper()
+	if !isNil(v) {
+		t.Fatalf("%sexpected nil, got %v", testContext(msgAndArgs), v)
+	}
+}
+
+func assertNotNil(t *testing.T, v any, msgAndArgs ...any) {
+	t.Helper()
+	if isNil(v) {
+		t.Fatalf("%sexpected non-nil", testContext(msgAndArgs))
+	}
+}
+
+func assertEmpty(t *testing.T, v any, msgAndArgs ...any) {
+	t.Helper()
+	if !isEmpty(v) {
+		t.Fatalf("%sexpected empty, got %v", testContext(msgAndArgs), v)
+	}
+}
+
+func assertLen(t *testing.T, v any, want int, msgAndArgs ...any) {
+	t.Helper()
+	got, ok := valueLen(v)
+	if !ok {
+		t.Fatalf("%sexpected value with length, got %T", testContext(msgAndArgs), v)
+	}
+	if want != got {
+		t.Fatalf("%swant length %v, got %v", testContext(msgAndArgs), want, got)
+	}
+}
+
+func assertContains(t *testing.T, s, substr string, msgAndArgs ...any) {
+	t.Helper()
+	if !core.Contains(s, substr) {
+		t.Fatalf("%sexpected %q to contain %q", testContext(msgAndArgs), s, substr)
+	}
+}
+
+func assertNotContains(t *testing.T, s, substr string, msgAndArgs ...any) {
+	t.Helper()
+	if core.Contains(s, substr) {
+		t.Fatalf("%sexpected %q not to contain %q", testContext(msgAndArgs), s, substr)
+	}
+}
+
+func assertInDelta(t *testing.T, want, got, delta float64, msgAndArgs ...any) {
+	t.Helper()
+	diff := want - got
+	if diff < 0 {
+		diff = -diff
+	}
+	if diff > delta {
+		t.Fatalf("%swant %v within %v, got %v", testContext(msgAndArgs), want, delta, got)
+	}
+}
diff --git a/tests/cli/session/Taskfile.yaml b/tests/cli/session/Taskfile.yaml
new file mode 100644
index 0000000..7ac44ab
--- /dev/null
+++ b/tests/cli/session/Taskfile.yaml
@@ -0,0 +1,14 @@
+version: "3"
+
+env:
+  GOWORK: off
+  GOCACHE: /tmp/go-session-go-build-cache
+
+tasks:
+  default:
+    deps: [test]
+
+  test:
+    dir: ../../..
+    cmds:
+      - go run ./tests/cli/session
diff --git a/tests/cli/session/main.go b/tests/cli/session/main.go
new file mode 100644
index 0000000..b59f838
--- /dev/null
+++ b/tests/cli/session/main.go
@@ -0,0 +1,82 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+package main
+
+import (
+	"os"
+	"strings"
+	"time"
+
+	session "dappco.re/go/session"
+)
+
+const transcript = `{"type":"user","timestamp":"2026-02-20T10:00:00Z","sessionId":"ax10-session","message":{"role":"user","content":[{"type":"text","text":"Run the AX-10 smoke test"}]}}
+{"type":"assistant","timestamp":"2026-02-20T10:00:01Z","sessionId":"ax10-session","message":{"role":"assistant","content":[{"type":"tool_use","name":"Bash","id":"tool-bash-1","input":{"command":"echo ax10","description":"smoke test"}}]}}
+{"type":"user","timestamp":"2026-02-20T10:00:02Z","sessionId":"ax10-session","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tool-bash-1","content":"ax10\n","is_error":false}]}}
+{"type":"assistant","timestamp":"2026-02-20T10:00:03Z","sessionId":"ax10-session","message":{"role":"assistant","content":[{"type":"text","text":"AX-10 complete"}]}}
+`
+
+func main() {
+	dir, err := os.MkdirTemp("", "go-session-ax10-")
+	requireNoError(err, "create temporary directory")
+	defer os.RemoveAll(dir)
+
+	transcriptPath := dir + "/ax10-session.jsonl"
+	requireNoError(os.WriteFile(transcriptPath, []byte(transcript), 0o600), "write transcript")
+
+	sess, stats, err := session.ParseTranscript(transcriptPath)
+	requireNoError(err, "parse transcript")
+	require(sess.ID == "ax10-session", "session ID should come from the file name")
+	require(sess.Path == transcriptPath, "session path should match the parsed file")
+	require(len(sess.Events) == 3, "expected user, tool, and assistant events")
+	require(stats.TotalLines == 4, "expected all transcript lines to be scanned")
+	require(stats.SkippedLines == 0, "expected no skipped transcript lines")
+	require(stats.OrphanedToolCalls == 0, "expected no orphaned tool calls")
+
+	tool := sess.Events[1]
+	require(tool.Type == "tool_use", "expected second event to be the tool call")
+	require(tool.Tool == "Bash", "expected Bash tool call")
+	require(tool.Input == "echo ax10 # smoke test", "expected Bash input to include command and description")
+	require(tool.Output == "ax10\n", "expected Bash output to be preserved")
+	require(tool.Duration == time.Second, "expected one second tool duration")
+	require(tool.Success, "expected successful tool call")
+
+	analytics := session.Analyse(sess)
+	require(analytics.EventCount == 3, "expected analytics event count")
+	require(analytics.ToolCounts["Bash"] == 1, "expected analytics Bash count")
+	require(analytics.SuccessRate == 1, "expected analytics success rate")
+	require(strings.Contains(session.FormatAnalytics(analytics), "Bash"), "expected formatted analytics to include Bash")
+
+	results, err := session.Search(dir, "ax10")
+	requireNoError(err, "search sessions")
+	require(len(results) == 1, "expected one search result")
+	require(results[0].SessionID == "ax10-session", "expected search result session ID")
+
+	sessions, err := session.ListSessions(dir)
+	requireNoError(err, "list sessions")
+	require(len(sessions) == 1, "expected one listed session")
+	require(sessions[0].ID == "ax10-session", "expected listed session ID")
+
+	fetched, _, err := session.FetchSession(dir, "ax10-session")
+	requireNoError(err, "fetch session")
+	require(fetched.ID == sess.ID, "expected fetched session to match parsed session")
+
+	htmlPath := dir + "/timeline.html"
+	requireNoError(session.RenderHTML(sess, htmlPath), "render HTML")
+	htmlBytes, err := os.ReadFile(htmlPath)
+	requireNoError(err, "read rendered HTML")
+	html := string(htmlBytes)
+	require(strings.Contains(html, "Session ax10"), "expected rendered HTML session title")
+	require(strings.Contains(html, "echo ax10"), "expected rendered HTML tool input")
+}
+
+func require(ok bool, msg string) {
+	if !ok {
+		panic(msg)
+	}
+}
+
+func requireNoError(err error, msg string) {
+	if err != nil {
+		panic(msg + ": " + err.Error())
+	}
+}
diff --git a/video.go b/video.go
index fc7ea70..c06e661 100644
--- a/video.go
+++ b/video.go
@@ -2,9 +2,9 @@
 package session
 
 import (
-	"io/fs"
-	"path"
-	"syscall"
+	"io/fs"   // Note: intrinsic — fs.FileInfo metadata for executable checks from hostFS.Stat; no core equivalent
+	"path"    // Note: intrinsic — PATH candidate and temporary tape path construction; no core equivalent
+	"syscall" // Note: intrinsic — ForkExec/Wait4 invokes VHS without importing banned os/exec; no core equivalent
 
 	core "dappco.re/go/core"
 )
diff --git a/video_test.go b/video_test.go
index f34571f..ec2b36a 100644
--- a/video_test.go
+++ b/video_test.go
@@ -6,8 +6,6 @@ import (
 	"time"
 
 	core "dappco.re/go/core"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestVideo_GenerateTapeBasicSession_Good(t *testing.T) {
@@ -34,14 +32,14 @@ func TestVideo_GenerateTapeBasicSession_Good(t *testing.T) {
 
 	tape := generateTape(sess, "/tmp/output.mp4")
 
-	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")
+	assertContains(t, tape, "Output /tmp/output.mp4")
+	assertContains(t, tape, "Set FontSize 16")
+	assertContains(t, tape, "tape-tes") // shortID
+	assertContains(t, tape, "2026-02-20 10:00")
+	assertContains(t, tape, `"$ go test ./..."`)
+	assertContains(t, tape, "PASS")
+	assertContains(t, tape, `"# ✓ OK"`)
+	assertContains(t, tape, "# Read: /tmp/file.go")
 }
 
 func TestVideo_GenerateTapeSkipsNonToolEvents_Good(t *testing.T) {
@@ -58,10 +56,10 @@ func TestVideo_GenerateTapeSkipsNonToolEvents_Good(t *testing.T) {
 	tape := generateTape(sess, "/tmp/out.mp4")
 
 	// User and assistant events should NOT appear in the tape
-	assert.NotContains(t, tape, "Hello")
-	assert.NotContains(t, tape, "Hi there")
+	assertNotContains(t, tape, "Hello")
+	assertNotContains(t, tape, "Hi there")
 	// Bash command should appear
-	assert.Contains(t, tape, "echo hi")
+	assertContains(t, tape, "echo hi")
 }
 
 func TestVideo_GenerateTapeFailedCommand_Good(t *testing.T) {
@@ -80,7 +78,7 @@ func TestVideo_GenerateTapeFailedCommand_Good(t *testing.T) {
 	}
 
 	tape := generateTape(sess, "/tmp/out.mp4")
-	assert.Contains(t, tape, `"# ✗ FAILED"`)
+	assertContains(t, tape, `"# ✗ FAILED"`)
 }
 
 func TestVideo_GenerateTapeLongOutput_Good(t *testing.T) {
@@ -100,7 +98,7 @@ func TestVideo_GenerateTapeLongOutput_Good(t *testing.T) {
 
 	tape := generateTape(sess, "/tmp/out.mp4")
 	// Output should be truncated to 200 chars + "..."
-	assert.Contains(t, tape, "...")
+	assertContains(t, tape, "...")
 }
 
 func TestVideo_GenerateTapeTaskEvent_Good(t *testing.T) {
@@ -117,7 +115,7 @@ func TestVideo_GenerateTapeTaskEvent_Good(t *testing.T) {
 	}
 
 	tape := generateTape(sess, "/tmp/out.mp4")
-	assert.Contains(t, tape, "# Agent: [research] Analyse code structure")
+	assertContains(t, tape, "# Agent: [research] Analyse code structure")
 }
 
 func TestVideo_GenerateTapeEditWriteEvents_Good(t *testing.T) {
@@ -131,8 +129,8 @@ func TestVideo_GenerateTapeEditWriteEvents_Good(t *testing.T) {
 	}
 
 	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)")
+	assertContains(t, tape, "# Edit: /tmp/app.go (edit)")
+	assertContains(t, tape, "# Write: /tmp/new.go (50 bytes)")
 }
 
 func TestVideo_GenerateTapeEmptySession_Good(t *testing.T) {
@@ -145,8 +143,8 @@ func TestVideo_GenerateTapeEmptySession_Good(t *testing.T) {
 	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")
+	assertContains(t, tape, "Output /tmp/out.mp4")
+	assertContains(t, tape, "Sleep 3s")
 	// No tool events
 	lines := core.Split(tape, "\n")
 	var toolLines int
@@ -156,7 +154,7 @@ func TestVideo_GenerateTapeEmptySession_Good(t *testing.T) {
 			toolLines++
 		}
 	}
-	assert.Equal(t, 0, toolLines)
+	assertEqual(t, 0, toolLines)
 }
 
 func TestVideo_GenerateTapeBashEmptyCommand_Bad(t *testing.T) {
@@ -170,23 +168,23 @@ func TestVideo_GenerateTapeBashEmptyCommand_Bad(t *testing.T) {
 
 	tape := generateTape(sess, "/tmp/out.mp4")
 	// Empty command should be skipped (extractCommand returns "")
-	assert.NotContains(t, tape, `"$ "`)
+	assertNotContains(t, tape, `"$ "`)
 }
 
 func TestVideo_ExtractCommandStripsDescriptionSuffix_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"))
+	assertEqual(t, "ls -la", extractCommand("ls -la # list files"))
+	assertEqual(t, "go test ./...", extractCommand("go test ./..."))
+	assertEqual(t, "echo hello", extractCommand("echo hello"))
 }
 
 func TestVideo_ExtractCommandNoDescription_Good(t *testing.T) {
-	assert.Equal(t, "plain command", extractCommand("plain command"))
+	assertEqual(t, "plain command", extractCommand("plain command"))
 }
 
 func TestVideo_ExtractCommandDescriptionAtStart_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)
+	assertEqual(t, " # description only", result)
 }
 
 func TestVideo_RenderMP4NoVHS_Ugly(t *testing.T) {
@@ -201,6 +199,6 @@ func TestVideo_RenderMP4NoVHS_Ugly(t *testing.T) {
 	}
 
 	err := RenderMP4(sess, "/tmp/test.mp4")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "vhs not installed")
+	requireError(t, err)
+	assertContains(t, err.Error(), "vhs not installed")
 }