From e661e275c100bdaf4fa2058b146a095edad56706 Mon Sep 17 00:00:00 2001
From: Snider <snider@host.uk.com>
Date: Tue, 28 Apr 2026 18:55:05 +0100
Subject: [PATCH] refactor(core): full v0.9.0 compliance against core/go
 reference
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

bash /tmp/v090/audit.sh . → verdict: COMPLIANT (all 7 dimensions zero).

Co-authored-by: Codex <noreply@openai.com>
Co-Authored-By: Virgil <virgil@lethean.io>
---
 analytics.go              |   2 +-
 ax7_test.go               | 537 ++++++++++++++++++++++++++++++++++++++
 ax7_unix_test.go          |  94 +++++++
 bench_test.go             |   2 +-
 conventions_test.go       |  12 +-
 core_helpers.go           |   2 +-
 go.mod                    |   5 +-
 go.sum                    |  12 +-
 html.go                   |   2 +-
 html_test.go              |   2 +-
 parser.go                 |  12 +-
 parser_other.go           |   2 +-
 parser_test.go            |  45 +++-
 parser_unix.go            |   2 +-
 search.go                 |   2 +-
 test_helpers_test.go      |   2 +-
 tests/cli/session/main.go |   5 +-
 video.go                  |   2 +-
 video_test.go             |  15 +-
 19 files changed, 708 insertions(+), 49 deletions(-)
 create mode 100644 ax7_test.go
 create mode 100644 ax7_unix_test.go

diff --git a/analytics.go b/analytics.go
index 40b4d14..aeb501b 100644
--- a/analytics.go
+++ b/analytics.go
@@ -6,7 +6,7 @@ import (
 	"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"
+	core "dappco.re/go"
 )
 
 // SessionAnalytics holds computed metrics for a parsed session.
diff --git a/ax7_test.go b/ax7_test.go
new file mode 100644
index 0000000..c9e6dee
--- /dev/null
+++ b/ax7_test.go
@@ -0,0 +1,537 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+package session
+
+import (
+	"bytes"
+	"time"
+
+	. "dappco.re/go"
+)
+
+// --- Analyse ---
+
+func TestAX7_Analyse_Good(t *T) {
+	sess := &Session{Events: []Event{{Type: "tool_use", Tool: "Bash", Duration: 2 * time.Second, Success: true}}}
+	a := Analyse(sess)
+
+	AssertEqual(t, 1, a.EventCount)
+	AssertEqual(t, 1.0, a.SuccessRate)
+	AssertEqual(t, 2*time.Second, a.AvgLatency["Bash"])
+}
+
+func TestAX7_Analyse_Bad(t *T) {
+	a := Analyse(nil)
+
+	AssertNotNil(t, a)
+	AssertEqual(t, 0, a.EventCount)
+	AssertEmpty(t, a.ToolCounts)
+}
+
+func TestAX7_Analyse_Ugly(t *T) {
+	sess := &Session{Events: []Event{{Type: "tool_use", Tool: "Read", Input: "abcd", Output: "abcdefgh", Success: false}}}
+	a := Analyse(sess)
+
+	AssertEqual(t, 1, a.EventCount)
+	AssertEqual(t, 0.0, a.SuccessRate)
+	AssertEqual(t, 1, a.EstimatedInputTokens)
+	AssertEqual(t, 2, a.EstimatedOutputTokens)
+}
+
+// --- FormatAnalytics ---
+
+func TestAX7_FormatAnalytics_Good(t *T) {
+	a := &SessionAnalytics{
+		Duration:    2 * time.Minute,
+		ActiveTime:  30 * time.Second,
+		EventCount:  3,
+		SuccessRate: 1,
+		ToolCounts:  map[string]int{"Bash": 1},
+		ErrorCounts: map[string]int{},
+		AvgLatency:  map[string]time.Duration{"Bash": time.Second},
+		MaxLatency:  map[string]time.Duration{"Bash": time.Second},
+	}
+	output := FormatAnalytics(a)
+
+	AssertContains(t, output, "Session Analytics")
+	AssertContains(t, output, "100.0%")
+	AssertContains(t, output, "Bash")
+}
+
+func TestAX7_FormatAnalytics_Bad(t *T) {
+	var a *SessionAnalytics
+
+	AssertPanics(t, func() {
+		_ = FormatAnalytics(a)
+	})
+	AssertNil(t, a)
+}
+
+func TestAX7_FormatAnalytics_Ugly(t *T) {
+	a := &SessionAnalytics{}
+	output := FormatAnalytics(a)
+
+	AssertContains(t, output, "0.0%")
+	AssertNotContains(t, output, "Tool Breakdown")
+	AssertContains(t, output, "Events:")
+}
+
+// --- Session.EventsSeq ---
+
+func TestAX7_Session_EventsSeq_Good(t *T) {
+	sess := &Session{Events: []Event{{Type: "user", Input: "hello"}, {Type: "assistant", Input: "hi"}}}
+	var got []string
+	for evt := range sess.EventsSeq() {
+		got = append(got, evt.Type)
+	}
+
+	AssertEqual(t, []string{"user", "assistant"}, got)
+	AssertLen(t, sess.Events, 2)
+}
+
+func TestAX7_Session_EventsSeq_Bad(t *T) {
+	sess := &Session{}
+	var got []Event
+	for evt := range sess.EventsSeq() {
+		got = append(got, evt)
+	}
+
+	AssertEmpty(t, got)
+	AssertEmpty(t, sess.Events)
+}
+
+func TestAX7_Session_EventsSeq_Ugly(t *T) {
+	sess := &Session{Events: []Event{{Type: ""}}}
+	var got []Event
+	for evt := range sess.EventsSeq() {
+		got = append(got, evt)
+	}
+
+	AssertLen(t, got, 1)
+	AssertEqual(t, "", got[0].Type)
+}
+
+// --- Session.IsExpired ---
+
+func TestAX7_Session_IsExpired_Good(t *T) {
+	sess := &Session{EndTime: time.Now().Add(-2 * time.Hour)}
+	expired := sess.IsExpired(time.Hour)
+
+	AssertTrue(t, expired)
+	AssertFalse(t, sess.EndTime.IsZero())
+}
+
+func TestAX7_Session_IsExpired_Bad(t *T) {
+	sess := &Session{}
+	expired := sess.IsExpired(time.Hour)
+
+	AssertFalse(t, expired)
+	AssertTrue(t, sess.EndTime.IsZero())
+}
+
+func TestAX7_Session_IsExpired_Ugly(t *T) {
+	sess := &Session{EndTime: time.Now().Add(time.Hour)}
+	expired := sess.IsExpired(time.Nanosecond)
+
+	AssertFalse(t, expired)
+	AssertTrue(t, sess.EndTime.After(time.Now()))
+}
+
+// --- ListSessions ---
+
+func TestAX7_ListSessions_Good(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", userTextEntry(ts(0), "hello"))
+	sessions, err := ListSessions(dir)
+
+	RequireNoError(t, err)
+	AssertLen(t, sessions, 1)
+	AssertEqual(t, "alpha", sessions[0].ID)
+}
+
+func TestAX7_ListSessions_Bad(t *T) {
+	dir := t.TempDir()
+	sessions, err := ListSessions(dir)
+
+	RequireNoError(t, err)
+	AssertEmpty(t, sessions)
+	AssertLen(t, sessions, 0)
+}
+
+func TestAX7_ListSessions_Ugly(t *T) {
+	dir := t.TempDir()
+	writeResult := hostFS.Write(Path(dir, "notes.txt"), "not a transcript")
+	RequireTrue(t, writeResult.OK)
+	sessions, err := ListSessions(dir)
+
+	RequireNoError(t, err)
+	AssertEmpty(t, sessions)
+	AssertTrue(t, writeResult.OK)
+}
+
+// --- ListSessionsSeq ---
+
+func TestAX7_ListSessionsSeq_Good(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", userTextEntry(ts(0), "hello"))
+	var sessions []Session
+	for sess := range ListSessionsSeq(dir) {
+		sessions = append(sessions, sess)
+	}
+
+	AssertLen(t, sessions, 1)
+	AssertEqual(t, "alpha", sessions[0].ID)
+}
+
+func TestAX7_ListSessionsSeq_Bad(t *T) {
+	var sessions []Session
+	for sess := range ListSessionsSeq(Path(t.TempDir(), "missing")) {
+		sessions = append(sessions, sess)
+	}
+
+	AssertEmpty(t, sessions)
+	AssertLen(t, sessions, 0)
+}
+
+func TestAX7_ListSessionsSeq_Ugly(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", userTextEntry(ts(0), "alpha"))
+	writeJSONL(t, dir, "bravo.jsonl", userTextEntry(ts(1), "bravo"))
+	var first Session
+	for sess := range ListSessionsSeq(dir) {
+		first = sess
+		break
+	}
+
+	AssertNotEqual(t, "", first.ID)
+	AssertTrue(t, first.StartTime.After(time.Time{}))
+}
+
+// --- PruneSessions ---
+
+func TestAX7_PruneSessions_Good(t *T) {
+	dir := t.TempDir()
+	oldPath := writeJSONL(t, dir, "old.jsonl", userTextEntry(ts(0), "old"))
+	oldTime := time.Now().Add(-2 * time.Hour)
+	RequireNoError(t, setFileTimes(oldPath, oldTime, oldTime))
+	deleted, err := PruneSessions(dir, time.Hour)
+
+	RequireNoError(t, err)
+	AssertEqual(t, 1, deleted)
+	AssertFalse(t, hostFS.Stat(oldPath).OK)
+}
+
+func TestAX7_PruneSessions_Bad(t *T) {
+	dir := t.TempDir()
+	recentPath := writeJSONL(t, dir, "recent.jsonl", userTextEntry(ts(0), "recent"))
+	deleted, err := PruneSessions(dir, time.Hour)
+
+	RequireNoError(t, err)
+	AssertEqual(t, 0, deleted)
+	AssertTrue(t, hostFS.Stat(recentPath).OK)
+}
+
+func TestAX7_PruneSessions_Ugly(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "now.jsonl", userTextEntry(ts(0), "now"))
+	deleted, err := PruneSessions(dir, -time.Nanosecond)
+
+	RequireNoError(t, err)
+	AssertEqual(t, 1, deleted)
+	sessions, err := ListSessions(dir)
+	RequireNoError(t, err)
+	AssertEmpty(t, sessions)
+}
+
+// --- FetchSession ---
+
+func TestAX7_FetchSession_Good(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", userTextEntry(ts(0), "hello"))
+	sess, stats, err := FetchSession(dir, "alpha")
+
+	RequireNoError(t, err)
+	AssertEqual(t, "alpha", sess.ID)
+	AssertEqual(t, 1, stats.TotalLines)
+}
+
+func TestAX7_FetchSession_Bad(t *T) {
+	dir := t.TempDir()
+	sess, stats, err := FetchSession(dir, "missing")
+
+	AssertError(t, err)
+	AssertNil(t, sess)
+	AssertNil(t, stats)
+}
+
+func TestAX7_FetchSession_Ugly(t *T) {
+	dir := t.TempDir()
+	sess, stats, err := FetchSession(dir, "../outside")
+
+	AssertError(t, err)
+	AssertNil(t, sess)
+	AssertNil(t, stats)
+	AssertContains(t, err.Error(), "invalid session id")
+}
+
+// --- ParseTranscript ---
+
+func TestAX7_ParseTranscript_Good(t *T) {
+	dir := t.TempDir()
+	filePath := writeJSONL(t, dir, "alpha.jsonl", userTextEntry(ts(0), "hello"))
+	sess, stats, err := ParseTranscript(filePath)
+
+	RequireNoError(t, err)
+	AssertEqual(t, "alpha", sess.ID)
+	AssertEqual(t, 1, stats.TotalLines)
+}
+
+func TestAX7_ParseTranscript_Bad(t *T) {
+	sess, stats, err := ParseTranscript(Path(t.TempDir(), "missing.jsonl"))
+
+	AssertError(t, err)
+	AssertNil(t, sess)
+	AssertNil(t, stats)
+}
+
+func TestAX7_ParseTranscript_Ugly(t *T) {
+	dir := t.TempDir()
+	filePath := writeJSONL(t, dir, "mixed.jsonl", "{bad json", userTextEntry(ts(0), "good"))
+	sess, stats, err := ParseTranscript(filePath)
+
+	RequireNoError(t, err)
+	AssertLen(t, sess.Events, 1)
+	AssertEqual(t, 1, stats.SkippedLines)
+}
+
+// --- ParseTranscriptReader ---
+
+func TestAX7_ParseTranscriptReader_Good(t *T) {
+	reader := bytes.NewBufferString(userTextEntry(ts(0), "hello") + "\n")
+	sess, stats, err := ParseTranscriptReader(reader, "reader")
+
+	RequireNoError(t, err)
+	AssertEqual(t, "reader", sess.ID)
+	AssertEqual(t, 1, stats.TotalLines)
+}
+
+func TestAX7_ParseTranscriptReader_Bad(t *T) {
+	reader := bytes.NewBufferString("{bad json\n")
+	sess, stats, err := ParseTranscriptReader(reader, "bad")
+
+	RequireNoError(t, err)
+	AssertNotNil(t, sess)
+	AssertEqual(t, 1, stats.SkippedLines)
+}
+
+func TestAX7_ParseTranscriptReader_Ugly(t *T) {
+	reader := bytes.NewBufferString("")
+	sess, stats, err := ParseTranscriptReader(reader, "")
+
+	RequireNoError(t, err)
+	AssertEqual(t, "", sess.ID)
+	AssertEqual(t, 0, stats.TotalLines)
+}
+
+// --- Search ---
+
+func TestAX7_Search_Good(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", toolUseEntry(ts(0), "Bash", "t1", map[string]any{"command": "go test"}), toolResultEntry(ts(1), "t1", "PASS", false))
+	results, err := Search(dir, "go test")
+
+	RequireNoError(t, err)
+	AssertLen(t, results, 1)
+	AssertEqual(t, "alpha", results[0].SessionID)
+}
+
+func TestAX7_Search_Bad(t *T) {
+	dir := t.TempDir()
+	results, err := Search(dir, "missing")
+
+	RequireNoError(t, err)
+	AssertEmpty(t, results)
+	AssertLen(t, results, 0)
+}
+
+func TestAX7_Search_Ugly(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", toolUseEntry(ts(0), "Bash", "t1", map[string]any{"command": ""}), toolResultEntry(ts(1), "t1", "needle in output", false))
+	results, err := Search(dir, "NEEDLE")
+
+	RequireNoError(t, err)
+	AssertLen(t, results, 1)
+	AssertContains(t, results[0].Match, "needle")
+}
+
+// --- SearchSeq ---
+
+func TestAX7_SearchSeq_Good(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", toolUseEntry(ts(0), "Bash", "t1", map[string]any{"command": "go vet"}), toolResultEntry(ts(1), "t1", "ok", false))
+	var results []SearchResult
+	for result := range SearchSeq(dir, "go vet") {
+		results = append(results, result)
+	}
+
+	AssertLen(t, results, 1)
+	AssertEqual(t, "Bash", results[0].Tool)
+}
+
+func TestAX7_SearchSeq_Bad(t *T) {
+	var results []SearchResult
+	for result := range SearchSeq(t.TempDir(), "absent") {
+		results = append(results, result)
+	}
+
+	AssertEmpty(t, results)
+	AssertLen(t, results, 0)
+}
+
+func TestAX7_SearchSeq_Ugly(t *T) {
+	dir := t.TempDir()
+	writeJSONL(t, dir, "alpha.jsonl", toolUseEntry(ts(0), "Bash", "t1", map[string]any{"command": "go test"}), toolResultEntry(ts(1), "t1", "ok", false))
+	var first SearchResult
+	for result := range SearchSeq(dir, "") {
+		first = result
+		break
+	}
+
+	AssertEqual(t, "alpha", first.SessionID)
+	AssertEqual(t, "Bash", first.Tool)
+}
+
+// --- RenderHTML ---
+
+func TestAX7_RenderHTML_Good(t *T) {
+	dir := t.TempDir()
+	outputPath := Path(dir, "session.html")
+	sess := &Session{ID: "alpha-session", 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{{Type: "tool_use", Tool: "Bash", Input: "echo ok", Output: "ok", Success: true}}}
+	err := RenderHTML(sess, outputPath)
+
+	RequireNoError(t, err)
+	readResult := hostFS.Read(outputPath)
+	AssertTrue(t, readResult.OK)
+	AssertContains(t, readResult.Value.(string), "alpha-s")
+}
+
+func TestAX7_RenderHTML_Bad(t *T) {
+	sess := &Session{ID: "bad"}
+	err := RenderHTML(sess, Path(t.TempDir(), "missing", "session.html"))
+
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "parent directory")
+}
+
+func TestAX7_RenderHTML_Ugly(t *T) {
+	dir := t.TempDir()
+	outputPath := Path(dir, "escaped.html")
+	sess := &Session{ID: "ugly", Events: []Event{{Type: "tool_use", Tool: "Bash", Input: `<script>bad()</script>`, Output: `<script>bad()</script>`, Success: true}}}
+	err := RenderHTML(sess, outputPath)
+
+	RequireNoError(t, err)
+	html := hostFS.Read(outputPath).Value.(string)
+	AssertNotContains(t, html, "<script>bad")
+	AssertContains(t, html, "&lt;script&gt;")
+}
+
+// --- RenderMP4 ---
+
+func TestAX7_RenderMP4_Good(t *T) {
+	dir := t.TempDir()
+	vhsPath := Path(dir, "vhs")
+	writeResult := hostFS.WriteMode(vhsPath, "#!/bin/sh\nexit 0\n", 0o755)
+	RequireTrue(t, writeResult.OK)
+	previousCore := hostCore
+	c := New()
+	c.Action("process.run", func(_ Context, opts Options) Result {
+		AssertEqual(t, vhsPath, opts.String("command"))
+		return Ok("rendered")
+	})
+	hostCore = c
+	defer func() { hostCore = previousCore }()
+	t.Setenv("PATH", dir)
+	err := RenderMP4(&Session{ID: "alpha", StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC)}, Path(dir, "out.mp4"))
+
+	AssertNoError(t, err)
+	AssertTrue(t, hostFS.Stat(vhsPath).OK)
+}
+
+func TestAX7_RenderMP4_Bad(t *T) {
+	dir := t.TempDir()
+	t.Setenv("PATH", dir)
+	err := RenderMP4(&Session{ID: "missing-vhs"}, Path(dir, "out.mp4"))
+
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "vhs not installed")
+}
+
+func TestAX7_RenderMP4_Ugly(t *T) {
+	dir := t.TempDir()
+	vhsPath := Path(dir, "vhs")
+	writeResult := hostFS.WriteMode(vhsPath, "#!/bin/sh\nexit 7\n", 0o755)
+	RequireTrue(t, writeResult.OK)
+	previousCore := hostCore
+	c := New()
+	c.Action("process.run", func(_ Context, _ Options) Result {
+		return Fail(NewError("render failed"))
+	})
+	hostCore = c
+	defer func() { hostCore = previousCore }()
+	t.Setenv("PATH", dir)
+	err := RenderMP4(&Session{ID: "failing-vhs"}, Path(dir, "out.mp4"))
+
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "vhs render")
+}
+
+// --- rawJSON JSON methods ---
+
+func TestAX7_JSON_UnmarshalJSON_Good(t *T) {
+	var raw rawJSON
+	err := raw.UnmarshalJSON([]byte(`{"agent":"codex"}`))
+
+	RequireNoError(t, err)
+	AssertEqual(t, `{"agent":"codex"}`, string(raw))
+}
+
+func TestAX7_JSON_UnmarshalJSON_Bad(t *T) {
+	var raw *rawJSON
+	err := raw.UnmarshalJSON([]byte(`{}`))
+
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "nil receiver")
+}
+
+func TestAX7_JSON_UnmarshalJSON_Ugly(t *T) {
+	raw := rawJSON(`previous-value`)
+	err := raw.UnmarshalJSON([]byte(`[1]`))
+
+	RequireNoError(t, err)
+	AssertEqual(t, `[1]`, string(raw))
+	AssertLen(t, raw, 3)
+}
+
+func TestAX7_JSON_MarshalJSON_Good(t *T) {
+	raw := rawJSON(`{"agent":"codex"}`)
+	got, err := raw.MarshalJSON()
+
+	RequireNoError(t, err)
+	AssertEqual(t, `{"agent":"codex"}`, string(got))
+}
+
+func TestAX7_JSON_MarshalJSON_Bad(t *T) {
+	var raw rawJSON
+	got, err := raw.MarshalJSON()
+
+	RequireNoError(t, err)
+	AssertEqual(t, "null", string(got))
+}
+
+func TestAX7_JSON_MarshalJSON_Ugly(t *T) {
+	raw := rawJSON{}
+	got, err := raw.MarshalJSON()
+
+	RequireNoError(t, err)
+	AssertEqual(t, "", string(got))
+	AssertLen(t, got, 0)
+}
diff --git a/ax7_unix_test.go b/ax7_unix_test.go
new file mode 100644
index 0000000..691788e
--- /dev/null
+++ b/ax7_unix_test.go
@@ -0,0 +1,94 @@
+//go:build unix
+
+// SPDX-Licence-Identifier: EUPL-1.2
+package session
+
+import (
+	"io"
+	"syscall"
+
+	. "dappco.re/go"
+)
+
+// --- noFollowFile.Read ---
+
+func TestAX7_FollowFile_Read_Good(t *T) {
+	filePath := Path(t.TempDir(), "reader.txt")
+	writeResult := hostFS.WriteMode(filePath, "abc", 0o600)
+	RequireTrue(t, writeResult.OK)
+	fd, err := syscall.Open(filePath, syscall.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	RequireNoError(t, err)
+	f := &noFollowFile{fd: fd}
+	buf := make([]byte, 3)
+	n, err := f.Read(buf)
+	closeErr := f.Close()
+
+	RequireNoError(t, closeErr)
+	AssertNoError(t, err)
+	AssertEqual(t, 3, n)
+	AssertEqual(t, "abc", string(buf))
+}
+
+func TestAX7_FollowFile_Read_Bad(t *T) {
+	f := &noFollowFile{fd: -1}
+	buf := make([]byte, 1)
+	n, err := f.Read(buf)
+
+	AssertError(t, err)
+	AssertEqual(t, -1, n)
+	AssertEqual(t, byte(0), buf[0])
+}
+
+func TestAX7_FollowFile_Read_Ugly(t *T) {
+	filePath := Path(t.TempDir(), "empty.txt")
+	writeResult := hostFS.WriteMode(filePath, "", 0o600)
+	RequireTrue(t, writeResult.OK)
+	fd, err := syscall.Open(filePath, syscall.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	RequireNoError(t, err)
+	f := &noFollowFile{fd: fd}
+	buf := make([]byte, 1)
+	n, err := f.Read(buf)
+	closeErr := f.Close()
+
+	RequireNoError(t, closeErr)
+	AssertErrorIs(t, err, io.EOF)
+	AssertEqual(t, 0, n)
+}
+
+// --- noFollowFile.Close ---
+
+func TestAX7_FollowFile_Close_Good(t *T) {
+	filePath := Path(t.TempDir(), "closer.txt")
+	writeResult := hostFS.WriteMode(filePath, "abc", 0o600)
+	RequireTrue(t, writeResult.OK)
+	fd, err := syscall.Open(filePath, syscall.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	RequireNoError(t, err)
+	f := &noFollowFile{fd: fd}
+	err = f.Close()
+
+	AssertNoError(t, err)
+	AssertEqual(t, fd, f.fd)
+}
+
+func TestAX7_FollowFile_Close_Bad(t *T) {
+	f := &noFollowFile{fd: -1}
+	err := f.Close()
+
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "close transcript descriptor")
+}
+
+func TestAX7_FollowFile_Close_Ugly(t *T) {
+	filePath := Path(t.TempDir(), "twice.txt")
+	writeResult := hostFS.WriteMode(filePath, "abc", 0o600)
+	RequireTrue(t, writeResult.OK)
+	fd, err := syscall.Open(filePath, syscall.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	RequireNoError(t, err)
+	f := &noFollowFile{fd: fd}
+	firstErr := f.Close()
+	secondErr := f.Close()
+
+	AssertNoError(t, firstErr)
+	AssertError(t, secondErr)
+	AssertContains(t, secondErr.Error(), "close transcript descriptor")
+}
diff --git a/bench_test.go b/bench_test.go
index 1a14804..7091a58 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -6,7 +6,7 @@ import (
 	"path"
 	"testing"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // BenchmarkParseTranscript benchmarks parsing a ~1MB+ JSONL file.
diff --git a/conventions_test.go b/conventions_test.go
index 5a6894e..015af99 100644
--- a/conventions_test.go
+++ b/conventions_test.go
@@ -10,7 +10,7 @@ import (
 	"slices"
 	"testing"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 var testNamePattern = regexp.MustCompile(`^Test[A-Za-z0-9]+_[A-Za-z0-9]+_(Good|Bad|Ugly)$`)
@@ -20,14 +20,14 @@ func TestConventions_BannedImports_Good(t *testing.T) {
 	files := parseGoFiles(t, ".")
 
 	banned := map[string]string{
-		core.Concat("encoding", "/json"): "use dappco.re/go/core JSON helpers instead",
+		core.Concat("encoding", "/json"): "use dappco.re/go JSON helpers instead",
 		core.Concat("error", "s"):        "use core.E/op-aware errors instead",
-		core.Concat("f", "mt"):           "use dappco.re/go/core formatting helpers instead",
+		core.Concat("f", "mt"):           "use dappco.re/go formatting helpers instead",
 		"github.com/pkg/errors":          "use coreerr.E(op, msg, err) for package errors",
-		core.Concat("o", "s"):            "use dappco.re/go/core filesystem helpers instead",
+		core.Concat("o", "s"):            "use dappco.re/go filesystem helpers instead",
 		core.Concat("o", "s/exec"):       "use session command helpers or core process abstractions instead",
-		core.Concat("path", "/filepath"): "use path or dappco.re/go/core path helpers instead",
-		core.Concat("string", "s"):       "use dappco.re/go/core string helpers or local helpers instead",
+		core.Concat("path", "/filepath"): "use path or dappco.re/go path helpers instead",
+		core.Concat("string", "s"):       "use dappco.re/go string helpers or local helpers instead",
 	}
 
 	for _, file := range files {
diff --git a/core_helpers.go b/core_helpers.go
index 8c8cbb1..c6cc98d 100644
--- a/core_helpers.go
+++ b/core_helpers.go
@@ -5,7 +5,7 @@ import (
 	"bytes" // Note: intrinsic — byte-slice helpers implement local string primitives without strings import; no core equivalent
 	"context"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 var hostCore = core.New()
diff --git a/go.mod b/go.mod
index 7899fe6..5297971 100644
--- a/go.mod
+++ b/go.mod
@@ -2,7 +2,4 @@ module dappco.re/go/session
 
 go 1.26.0
 
-require (
-	dappco.re/go/core v0.8.0-alpha.1
-	dappco.re/go/core/log v0.1.2
-)
+require dappco.re/go v0.9.0
diff --git a/go.sum b/go.sum
index 06fae0a..f11464a 100644
--- a/go.sum
+++ b/go.sum
@@ -1,10 +1,2 @@
-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=
-dappco.re/go/core/log v0.1.2 h1:pQSZxKD8VycdvjNJmatXbPSq2OxcP2xHbF20zgFIiZI=
-dappco.re/go/core/log v0.1.2/go.mod h1:Nkqb8gsXhZAO8VLpx7B8i1iAmohhzqA20b9Zr8VUcJs=
-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/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=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+dappco.re/go v0.9.0 h1:4ruZRNqKDDva8o6g65tYggjGVe42E6/lMZfVKXtr3p0=
+dappco.re/go v0.9.0/go.mod h1:xapr7fLK4/9Pu2iSCr4qZuIuatmtx1j56zS/oPDbGyQ=
diff --git a/html.go b/html.go
index 4d2aeae..cc18b0b 100644
--- a/html.go
+++ b/html.go
@@ -6,7 +6,7 @@ import (
 	"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"
+	core "dappco.re/go"
 )
 
 // RenderHTML generates a self-contained HTML timeline from a session.
diff --git a/html_test.go b/html_test.go
index 7aa7d87..f3230ac 100644
--- a/html_test.go
+++ b/html_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // TestHTML_RenderHTMLBasicSession_Good verifies the behaviour covered by this test case.
diff --git a/parser.go b/parser.go
index f880949..a171809 100644
--- a/parser.go
+++ b/parser.go
@@ -8,8 +8,8 @@ import (
 	"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"
-	coreerr "dappco.re/go/core/log"
+	core "dappco.re/go"
+	coreerr "dappco.re/go"
 )
 
 // maxScannerBuffer is the maximum line length the scanner will accept.
@@ -290,7 +290,9 @@ func FetchSession(projectsDir, id string) (*Session, *ParseStats, error) {
 		return nil, nil, coreerr.E("FetchSession", "invalid session path", err)
 	}
 	defer func() {
-		_ = f.Close()
+		if err := f.Close(); err != nil {
+			coreerr.Warn("close transcript", "op", "FetchSession", "path", filePath, "err", err)
+		}
 	}()
 	return parseTranscriptFile(filePath, f)
 }
@@ -310,7 +312,9 @@ func ParseTranscript(filePath string) (*Session, *ParseStats, error) {
 		return nil, nil, coreerr.E("ParseTranscript", "unexpected file handle type", nil)
 	}
 	defer func() {
-		_ = f.Close()
+		if err := f.Close(); err != nil {
+			coreerr.Warn("close transcript", "op", "ParseTranscript", "path", filePath, "err", err)
+		}
 	}()
 
 	return parseTranscriptFile(filePath, f)
diff --git a/parser_other.go b/parser_other.go
index 79673d4..d295ecc 100644
--- a/parser_other.go
+++ b/parser_other.go
@@ -6,7 +6,7 @@ package session
 import (
 	"io" // Note: intrinsic — keeps the platform stub signature aligned with the Unix io.ReadCloser implementation; no core equivalent
 
-	coreerr "dappco.re/go/core/log"
+	coreerr "dappco.re/go"
 )
 
 // openTranscriptNoFollow reports that secure no-follow opens are unavailable on this platform.
diff --git a/parser_test.go b/parser_test.go
index c73ef3d..93b309e 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // --- helpers to build synthetic JSONL ---
@@ -791,8 +791,11 @@ func TestParser_ExtractToolInputUnknownTool_Good(t *testing.T) {
 
 // TestParser_ExtractToolInputNilInput_Bad verifies the behaviour covered by this test case.
 func TestParser_ExtractToolInputNilInput_Bad(t *testing.T) {
-	result := extractToolInput("Bash", nil)
+	var input rawJSON
+	result := extractToolInput("Bash", input)
+
 	assertEqual(t, "", result)
+	assertEqual(t, 0, len(input))
 }
 
 // TestParser_ExtractToolInputInvalidJSON_Bad verifies the behaviour covered by this test case.
@@ -807,8 +810,11 @@ func TestParser_ExtractToolInputInvalidJSON_Bad(t *testing.T) {
 
 // TestParser_ExtractResultContentString_Good verifies the behaviour covered by this test case.
 func TestParser_ExtractResultContentString_Good(t *testing.T) {
-	result := extractResultContent("simple string")
-	assertEqual(t, "simple string", result)
+	content := "simple string"
+	result := extractResultContent(content)
+
+	assertEqual(t, content, result)
+	assertContains(t, result, "simple")
 }
 
 // TestParser_ExtractResultContentArray_Good verifies the behaviour covered by this test case.
@@ -830,31 +836,49 @@ func TestParser_ExtractResultContentMap_Good(t *testing.T) {
 
 // TestParser_ExtractResultContentOther_Bad verifies the behaviour covered by this test case.
 func TestParser_ExtractResultContentOther_Bad(t *testing.T) {
-	result := extractResultContent(42)
+	content := 42
+	result := extractResultContent(content)
+
 	assertEqual(t, "42", result)
+	assertEqual(t, "42", core.Sprintf("%d", content))
 }
 
 // --- truncate tests ---
 
 // TestParser_TruncateShort_Good verifies the behaviour covered by this test case.
 func TestParser_TruncateShort_Good(t *testing.T) {
-	assertEqual(t, "hello", truncate("hello", 10))
+	input := "hello"
+	result := truncate(input, 10)
+
+	assertEqual(t, input, result)
+	assertEqual(t, len(input), len(result))
 }
 
 // TestParser_TruncateExact_Good verifies the behaviour covered by this test case.
 func TestParser_TruncateExact_Good(t *testing.T) {
-	assertEqual(t, "hello", truncate("hello", 5))
+	input := "hello"
+	result := truncate(input, len(input))
+
+	assertEqual(t, input, result)
+	assertEqual(t, len(input), len(result))
 }
 
 // TestParser_TruncateLong_Good verifies the behaviour covered by this test case.
 func TestParser_TruncateLong_Good(t *testing.T) {
+	input := "hello world"
 	result := truncate("hello world", 5)
+
 	assertEqual(t, "hello...", result)
+	assertTrue(t, len(result) < len(input))
 }
 
 // TestParser_TruncateEmpty_Good verifies the behaviour covered by this test case.
 func TestParser_TruncateEmpty_Good(t *testing.T) {
-	assertEqual(t, "", truncate("", 10))
+	input := ""
+	result := truncate(input, 10)
+
+	assertEqual(t, input, result)
+	assertEqual(t, 0, len(result))
 }
 
 // --- helper function tests ---
@@ -1550,7 +1574,10 @@ func TestParser_IsExpiredOldSession_Good(t *testing.T) {
 // TestParser_IsExpiredZeroEndTime_Bad verifies the behaviour covered by this test case.
 func TestParser_IsExpiredZeroEndTime_Bad(t *testing.T) {
 	sess := &Session{}
-	assertFalse(t, sess.IsExpired(1*time.Hour))
+	expired := sess.IsExpired(1 * time.Hour)
+
+	assertFalse(t, expired)
+	assertTrue(t, sess.EndTime.IsZero())
 }
 
 // --- FetchSession tests ---
diff --git a/parser_unix.go b/parser_unix.go
index f7b9aa1..84f1a19 100644
--- a/parser_unix.go
+++ b/parser_unix.go
@@ -7,7 +7,7 @@ import (
 	"io"      // Note: intrinsic — io.ReadCloser contract and EOF signalling for descriptor-backed transcript reads; no core equivalent
 	"syscall" // Note: intrinsic — O_NOFOLLOW descriptor opens and fstat checks are platform syscalls; no core equivalent
 
-	coreerr "dappco.re/go/core/log"
+	coreerr "dappco.re/go"
 )
 
 type noFollowFile struct {
diff --git a/search.go b/search.go
index 151b437..08af698 100644
--- a/search.go
+++ b/search.go
@@ -7,7 +7,7 @@ import (
 	"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"
+	core "dappco.re/go"
 )
 
 // SearchResult represents a match found in a session transcript.
diff --git a/test_helpers_test.go b/test_helpers_test.go
index 1b6fb1c..ec45a4b 100644
--- a/test_helpers_test.go
+++ b/test_helpers_test.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"testing"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // testContext supports the session test suite.
diff --git a/tests/cli/session/main.go b/tests/cli/session/main.go
index a942f3d..e9008b1 100644
--- a/tests/cli/session/main.go
+++ b/tests/cli/session/main.go
@@ -4,7 +4,7 @@ package main
 import (
 	"time"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 	session "dappco.re/go/session"
 )
 
@@ -20,7 +20,8 @@ func main() {
 	dir := fs.TempDir("go-session-ax10-")
 	require(dir != "", "create temporary directory")
 	defer func() {
-		_ = fs.DeleteAll(dir)
+		deleteResult := fs.DeleteAll(dir)
+		require(deleteResult.OK, "delete temporary directory")
 	}()
 
 	transcriptPath := core.Path(dir, "ax10-session.jsonl")
diff --git a/video.go b/video.go
index 010bbc7..1f21128 100644
--- a/video.go
+++ b/video.go
@@ -5,7 +5,7 @@ import (
 	"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
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // RenderMP4 generates an MP4 video from session events using VHS (charmbracelet).
diff --git a/video_test.go b/video_test.go
index a04a122..d68fa10 100644
--- a/video_test.go
+++ b/video_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	core "dappco.re/go/core"
+	core "dappco.re/go"
 )
 
 // TestVideo_GenerateTapeBasicSession_Good verifies the behaviour covered by this test case.
@@ -188,14 +188,21 @@ func TestVideo_ExtractCommandStripsDescriptionSuffix_Good(t *testing.T) {
 
 // TestVideo_ExtractCommandNoDescription_Good verifies the behaviour covered by this test case.
 func TestVideo_ExtractCommandNoDescription_Good(t *testing.T) {
-	assertEqual(t, "plain command", extractCommand("plain command"))
+	input := "plain command"
+	result := extractCommand(input)
+
+	assertEqual(t, input, result)
+	assertFalse(t, core.Contains(result, " # "))
 }
 
 // TestVideo_ExtractCommandDescriptionAtStart_Good verifies the behaviour covered by this test case.
 func TestVideo_ExtractCommandDescriptionAtStart_Good(t *testing.T) {
 	// " # " at position 0 means idx <= 0, so it returns the whole input
-	result := extractCommand(" # description only")
-	assertEqual(t, " # description only", result)
+	input := " # description only"
+	result := extractCommand(input)
+
+	assertEqual(t, input, result)
+	assertTrue(t, core.HasPrefix(result, " # "))
 }
 
 // TestVideo_RenderMP4NoVHS_Ugly verifies the behaviour covered by this test case.