From 0f1eb525a4f7e4a927442450d80dc6da852ea4a8 Mon Sep 17 00:00:00 2001
From: "user.email" <snider@host.uk.com>
Date: Tue, 28 Apr 2026 19:16:44 +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>
---
 go.mod                        |  22 +-
 go.sum                        |  27 +-
 pkg/help/ax7_test.go          | 635 ++++++++++++++++++++++++++++++++++
 pkg/help/catalog.go           |  11 +-
 pkg/help/catalog_test.go      | 137 ++++----
 pkg/help/generate_test.go     |  95 +++--
 pkg/help/ingest_test.go       | 185 +++++-----
 pkg/help/integration_test.go  |  67 ++--
 pkg/help/layout.go            | 142 +++-----
 pkg/help/layout_test.go       | 105 +++---
 pkg/help/parser_test.go       | 331 +++++++++---------
 pkg/help/render_test.go       | 133 ++++---
 pkg/help/search_bench_test.go |  18 +-
 pkg/help/search_test.go       | 495 +++++++++++++-------------
 pkg/help/server.go            |   8 +-
 pkg/help/server_test.go       | 131 ++++---
 pkg/help/stemmer_test.go      |  69 ++--
 pkg/help/templates_test.go    |  21 +-
 18 files changed, 1586 insertions(+), 1046 deletions(-)
 create mode 100644 pkg/help/ax7_test.go

diff --git a/go.mod b/go.mod
index 05eec89..63add03 100644
--- a/go.mod
+++ b/go.mod
@@ -3,27 +3,9 @@ module dappco.re/go/core/docs
 go 1.26.0
 
 require (
-	dappco.re/go/core/html v0.1.8
-	dappco.re/go/core/log v0.0.4
-	github.com/stretchr/testify v1.11.1
+	dappco.re/go v0.9.0
 	github.com/yuin/goldmark v1.7.16
 	gopkg.in/yaml.v3 v3.0.1
 )
 
-require (
-	dappco.re/go/core v0.5.0
-	dappco.re/go/core/api v0.2.0
-	dappco.re/go/core/i18n v0.2.0
-	dappco.re/go/core/io v0.2.0
-	dappco.re/go/core/log v0.1.0
-	dappco.re/go/core/process v0.3.0
-	dappco.re/go/core/scm v0.4.0
-	dappco.re/go/core/store v0.2.0
-	dappco.re/go/core/ws v0.3.0
-	dappco.re/go/core v0.3.3 // indirect
-	dappco.re/go/core/i18n v0.1.8 // indirect
-	dappco.re/go/core/inference v0.1.7 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	golang.org/x/text v0.35.0 // indirect
-)
+replace dappco.re/go => ../go
diff --git a/go.sum b/go.sum
index 66b27db..30d04fa 100644
--- a/go.sum
+++ b/go.sum
@@ -1,31 +1,6 @@
-forge.lthn.ai/core/go v0.3.3 h1:kYYZ2nRYy0/Be3cyuLJspRjLqTMxpckVyhb/7Sw2gd0=
-forge.lthn.ai/core/go v0.3.3/go.mod h1:Cp4ac25pghvO2iqOu59t1GyngTKVOzKB5/VPdhRi9CQ=
-forge.lthn.ai/core/go-html v0.1.8 h1:yfeM9Gt0Vsq0x6px23QfuptKlSNmHW6LINUcM8QjJ9g=
-forge.lthn.ai/core/go-html v0.1.8/go.mod h1:7iEq9BqIHRxooz0Ks5fCd4SRSZBem20RRP9kmmfAYjc=
-forge.lthn.ai/core/go-i18n v0.1.8 h1:+G/w5KVmu9NUoS//fRUseBKHQO+sNeB+RSlmhlz7OYM=
-forge.lthn.ai/core/go-i18n v0.1.8/go.mod h1:4IdsNILKU7nVSJf8gEjD+Iu2YfqpM0hrRNJFclPJI/k=
-forge.lthn.ai/core/go-inference v0.1.7 h1:9Dy6v03jX5ZRH3n5iTzlYyGtucuBIgSe+S7GWvBzx9Q=
-forge.lthn.ai/core/go-inference v0.1.7/go.mod h1:jfWz+IJX55wAH98+ic6FEqqGB6/P31CHlg7VY7pxREw=
-forge.lthn.ai/core/go-log v0.0.4 h1:KTuCEPgFmuM8KJfnyQ8vPOU1Jg654W74h8IJvfQMfv0=
-forge.lthn.ai/core/go-log v0.0.4/go.mod h1:r14MXKOD3LF/sI8XUJQhRk/SZHBE7jAFVuCfgkXoZPw=
-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=
 github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
 github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 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/pkg/help/ax7_test.go b/pkg/help/ax7_test.go
new file mode 100644
index 0000000..7ddff1c
--- /dev/null
+++ b/pkg/help/ax7_test.go
@@ -0,0 +1,635 @@
+package help
+
+import (
+	. "dappco.re/go"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"slices"
+)
+
+func ax7EmptyCatalog() *Catalog {
+	return &Catalog{
+		topics: make(map[string]*Topic),
+		index:  newSearchIndex(),
+	}
+}
+
+func ax7Topic() *Topic {
+	return &Topic{
+		ID:      "agent-guide",
+		Title:   "Agent Guide",
+		Content: "# Agent Guide\n\nRun the **agent** from the terminal.\n",
+		Tags:    []string{"cli", "agent"},
+		Sections: []Section{
+			{ID: "agent-guide", Title: "Agent Guide", Level: 1, Content: "Run the agent."},
+		},
+		Related: []string{"config"},
+	}
+}
+
+func ax7Catalog() *Catalog {
+	c := ax7EmptyCatalog()
+	c.Add(ax7Topic())
+	c.Add(&Topic{ID: "config", Title: "Configuration", Content: "Configure the agent.", Tags: []string{"setup"}})
+	return c
+}
+
+func TestAX7_RenderMarkdown_Good(t *T) {
+	html, err := RenderMarkdown("# Agent\n\nRun the **agent**.")
+	RequireNoError(t, err)
+	AssertContains(t, html, "<h1>Agent</h1>")
+	AssertContains(t, html, "<strong>agent</strong>")
+}
+
+func TestAX7_RenderMarkdown_Bad(t *T) {
+	html, err := RenderMarkdown("")
+	RequireNoError(t, err)
+	AssertEqual(t, "", html)
+	AssertNotContains(t, html, "<h1>")
+}
+
+func TestAX7_RenderMarkdown_Ugly(t *T) {
+	html, err := RenderMarkdown(`<div class="raw">agent</div>`)
+	RequireNoError(t, err)
+	AssertContains(t, html, `<div class="raw">agent</div>`)
+	AssertNotContains(t, html, "&lt;div")
+}
+
+func TestAX7_Generate_Good(t *T) {
+	dir := t.TempDir()
+	err := Generate(ax7Catalog(), dir)
+	RequireNoError(t, err)
+	_, err = os.Stat(filepath.Join(dir, "index.html"))
+	AssertNoError(t, err)
+}
+
+func TestAX7_Generate_Bad(t *T) {
+	dir := t.TempDir()
+	outputFile := filepath.Join(dir, "site")
+	RequireNoError(t, os.WriteFile(outputFile, []byte("not a directory"), 0o644))
+	err := Generate(ax7Catalog(), outputFile)
+	AssertError(t, err)
+}
+
+func TestAX7_Generate_Ugly(t *T) {
+	dir := t.TempDir()
+	err := Generate(ax7EmptyCatalog(), dir)
+	RequireNoError(t, err)
+	data, err := os.ReadFile(filepath.Join(dir, "search-index.json"))
+	RequireNoError(t, err)
+	AssertContains(t, string(data), "[]")
+}
+
+func TestAX7_NewServer_Good(t *T) {
+	c := ax7Catalog()
+	srv := NewServer(c, ":8080")
+	AssertNotNil(t, srv)
+	AssertEqual(t, c, srv.catalog)
+	AssertNotNil(t, srv.mux)
+}
+
+func TestAX7_NewServer_Bad(t *T) {
+	srv := NewServer(nil, "")
+	AssertNotNil(t, srv)
+	AssertNil(t, srv.catalog)
+	AssertEqual(t, "", srv.addr)
+}
+
+func TestAX7_NewServer_Ugly(t *T) {
+	srv := NewServer(ax7Catalog(), "127.0.0.1:-1")
+	AssertNotNil(t, srv)
+	AssertEqual(t, "127.0.0.1:-1", srv.addr)
+	AssertNotNil(t, srv.mux)
+}
+
+func TestAX7_Server_ServeHTTP_Good(t *T) {
+	srv := NewServer(ax7Catalog(), ":0")
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	srv.ServeHTTP(rec, req)
+	AssertEqual(t, http.StatusOK, rec.Code)
+}
+
+func TestAX7_Server_ServeHTTP_Bad(t *T) {
+	srv := NewServer(ax7Catalog(), ":0")
+	req := httptest.NewRequest(http.MethodGet, "/topics/missing", nil)
+	rec := httptest.NewRecorder()
+	srv.ServeHTTP(rec, req)
+	AssertEqual(t, http.StatusNotFound, rec.Code)
+}
+
+func TestAX7_Server_ServeHTTP_Ugly(t *T) {
+	srv := NewServer(ax7Catalog(), ":0")
+	req := httptest.NewRequest(http.MethodGet, "/api/search", nil)
+	rec := httptest.NewRecorder()
+	srv.ServeHTTP(rec, req)
+	AssertEqual(t, http.StatusBadRequest, rec.Code)
+}
+
+func TestAX7_Server_ListenAndServe_Good(t *T) {
+	srv := NewServer(ax7Catalog(), "127.0.0.1:-1")
+	err := srv.ListenAndServe()
+	AssertError(t, err)
+	AssertNotNil(t, srv.mux)
+}
+
+func TestAX7_Server_ListenAndServe_Bad(t *T) {
+	srv := NewServer(ax7Catalog(), "bad addr")
+	err := srv.ListenAndServe()
+	AssertError(t, err)
+	AssertEqual(t, "bad addr", srv.addr)
+}
+
+func TestAX7_Server_ListenAndServe_Ugly(t *T) {
+	var srv *Server
+	AssertPanics(t, func() {
+		_ = srv.ListenAndServe()
+	})
+	AssertNil(t, srv)
+}
+
+func TestAX7_ParseHelpText_Good(t *T) {
+	topic := ParseHelpText("agent run", "Usage:\n  agent run [flags]\n\nFlags:\n  --fast")
+	AssertEqual(t, "agent-run", topic.ID)
+	AssertContains(t, topic.Content, "## Usage")
+	AssertContains(t, topic.Content, "--fast")
+}
+
+func TestAX7_ParseHelpText_Bad(t *T) {
+	topic := ParseHelpText("empty", "")
+	AssertEqual(t, "empty", topic.ID)
+	AssertEqual(t, "", topic.Content)
+	AssertEqual(t, []string{"cli", "empty"}, topic.Tags)
+}
+
+func TestAX7_ParseHelpText_Ugly(t *T) {
+	topic := ParseHelpText("cli", "Root command.\nSee also: agent run, config")
+	AssertEqual(t, []string{"cli"}, topic.Tags)
+	AssertEqual(t, []string{"agent-run", "config"}, topic.Related)
+	AssertNotContains(t, topic.Content, "See also")
+}
+
+func TestAX7_IngestCLIHelp_Good(t *T) {
+	c := IngestCLIHelp(map[string]string{"agent run": "Run agent.", "agent stop": "Stop agent."})
+	topics := c.List()
+	AssertLen(t, topics, 2)
+	AssertNotEmpty(t, c.Search("agent"))
+}
+
+func TestAX7_IngestCLIHelp_Bad(t *T) {
+	c := IngestCLIHelp(map[string]string{})
+	topics := c.List()
+	AssertEmpty(t, topics)
+	AssertNil(t, c.Search(""))
+}
+
+func TestAX7_IngestCLIHelp_Ugly(t *T) {
+	c := IngestCLIHelp(map[string]string{"cli": "CLI root command."})
+	topic, err := c.Get("cli")
+	RequireNoError(t, err)
+	AssertEqual(t, []string{"cli"}, topic.Tags)
+	AssertEqual(t, "Cli", topic.Title)
+}
+
+func TestAX7_DefaultCatalog_Good(t *T) {
+	c := DefaultCatalog()
+	topics := c.List()
+	AssertGreaterOrEqual(t, len(topics), 2)
+	AssertNotEmpty(t, c.Search("configuration"))
+}
+
+func TestAX7_DefaultCatalog_Bad(t *T) {
+	c := DefaultCatalog()
+	topic, err := c.Get("missing")
+	AssertNil(t, topic)
+	AssertError(t, err, "topic not found")
+}
+
+func TestAX7_DefaultCatalog_Ugly(t *T) {
+	c := DefaultCatalog()
+	list := c.List()
+	list[0] = nil
+	topic, err := c.Get("getting-started")
+	RequireNoError(t, err)
+	AssertEqual(t, "Getting Started", topic.Title)
+}
+
+func TestAX7_Catalog_Add_Good(t *T) {
+	c := ax7EmptyCatalog()
+	topic := ax7Topic()
+	c.Add(topic)
+	got, err := c.Get("agent-guide")
+	RequireNoError(t, err)
+	AssertEqual(t, topic, got)
+}
+
+func TestAX7_Catalog_Add_Bad(t *T) {
+	c := ax7EmptyCatalog()
+	c.Add(&Topic{ID: "agent", Title: "Old"})
+	c.Add(&Topic{ID: "agent", Title: "New"})
+	got, err := c.Get("agent")
+	RequireNoError(t, err)
+	AssertEqual(t, "New", got.Title)
+}
+
+func TestAX7_Catalog_Add_Ugly(t *T) {
+	c := ax7EmptyCatalog()
+	c.Add(&Topic{ID: "", Title: "Empty ID", Content: "edge"})
+	got, err := c.Get("")
+	RequireNoError(t, err)
+	AssertEqual(t, "Empty ID", got.Title)
+}
+
+func TestAX7_Catalog_List_Good(t *T) {
+	c := ax7Catalog()
+	topics := c.List()
+	AssertLen(t, topics, 2)
+	AssertNotNil(t, topics[0])
+}
+
+func TestAX7_Catalog_List_Bad(t *T) {
+	c := ax7EmptyCatalog()
+	topics := c.List()
+	AssertEmpty(t, topics)
+	AssertNotNil(t, c.index)
+}
+
+func TestAX7_Catalog_List_Ugly(t *T) {
+	c := ax7EmptyCatalog()
+	c.Add(&Topic{ID: "dup", Title: "One"})
+	c.Add(&Topic{ID: "dup", Title: "Two"})
+	topics := c.List()
+	AssertLen(t, topics, 1)
+	AssertEqual(t, "Two", topics[0].Title)
+}
+
+func TestAX7_Catalog_All_Good(t *T) {
+	c := ax7Catalog()
+	topics := slices.Collect(c.All())
+	AssertLen(t, topics, 2)
+	AssertNotNil(t, topics[0])
+}
+
+func TestAX7_Catalog_All_Bad(t *T) {
+	c := ax7EmptyCatalog()
+	topics := slices.Collect(c.All())
+	AssertEmpty(t, topics)
+	AssertNotNil(t, c.topics)
+}
+
+func TestAX7_Catalog_All_Ugly(t *T) {
+	c := ax7EmptyCatalog()
+	c.Add(&Topic{ID: "", Title: "Empty"})
+	topics := slices.Collect(c.All())
+	AssertLen(t, topics, 1)
+	AssertEqual(t, "", topics[0].ID)
+}
+
+func TestAX7_Catalog_Search_Good(t *T) {
+	c := ax7Catalog()
+	results := c.Search("agent")
+	AssertNotEmpty(t, results)
+	AssertEqual(t, "agent-guide", results[0].Topic.ID)
+}
+
+func TestAX7_Catalog_Search_Bad(t *T) {
+	c := ax7Catalog()
+	results := c.Search("")
+	AssertNil(t, results)
+	AssertNotNil(t, c.index)
+}
+
+func TestAX7_Catalog_Search_Ugly(t *T) {
+	c := ax7Catalog()
+	results := c.Search("!@#$")
+	AssertEmpty(t, results)
+	AssertNotNil(t, c.topics)
+}
+
+func TestAX7_Catalog_SearchResults_Good(t *T) {
+	c := ax7Catalog()
+	results := slices.Collect(c.SearchResults("agent"))
+	AssertNotEmpty(t, results)
+	AssertEqual(t, "agent-guide", results[0].Topic.ID)
+}
+
+func TestAX7_Catalog_SearchResults_Bad(t *T) {
+	c := ax7Catalog()
+	results := slices.Collect(c.SearchResults(""))
+	AssertEmpty(t, results)
+	AssertNotNil(t, c.index)
+}
+
+func TestAX7_Catalog_SearchResults_Ugly(t *T) {
+	c := ax7Catalog()
+	results := slices.Collect(c.SearchResults("zzzz"))
+	AssertEmpty(t, results)
+	AssertNotNil(t, c.topics)
+}
+
+func TestAX7_LoadContentDir_Good(t *T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "agent.md")
+	RequireNoError(t, os.WriteFile(path, []byte("---\ntitle: Agent\n---\n\n# Agent\n"), 0o644))
+	c, err := LoadContentDir(dir)
+	RequireNoError(t, err)
+	AssertLen(t, c.List(), 1)
+}
+
+func TestAX7_LoadContentDir_Bad(t *T) {
+	c, err := LoadContentDir(filepath.Join(t.TempDir(), "missing"))
+	AssertNil(t, c)
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "walking directory")
+}
+
+func TestAX7_LoadContentDir_Ugly(t *T) {
+	dir := t.TempDir()
+	RequireNoError(t, os.WriteFile(filepath.Join(dir, "skip.txt"), []byte("# Skip\n"), 0o644))
+	RequireNoError(t, os.WriteFile(filepath.Join(dir, "KEEP.MD"), []byte("# Keep\n"), 0o644))
+	c, err := LoadContentDir(dir)
+	RequireNoError(t, err)
+	AssertLen(t, c.List(), 1)
+}
+
+func TestAX7_Catalog_Get_Good(t *T) {
+	c := ax7Catalog()
+	topic, err := c.Get("agent-guide")
+	RequireNoError(t, err)
+	AssertEqual(t, "Agent Guide", topic.Title)
+}
+
+func TestAX7_Catalog_Get_Bad(t *T) {
+	c := ax7Catalog()
+	topic, err := c.Get("missing")
+	AssertNil(t, topic)
+	AssertError(t, err)
+	AssertContains(t, err.Error(), "missing")
+}
+
+func TestAX7_Catalog_Get_Ugly(t *T) {
+	c := ax7EmptyCatalog()
+	c.Add(&Topic{ID: "", Title: "Empty ID"})
+	topic, err := c.Get("")
+	RequireNoError(t, err)
+	AssertEqual(t, "Empty ID", topic.Title)
+}
+
+func TestAX7_ParseTopic_Good(t *T) {
+	topic, err := ParseTopic("agent.md", []byte("---\ntitle: Agent\n---\n\n# Agent\n\nBody"))
+	RequireNoError(t, err)
+	AssertEqual(t, "Agent", topic.Title)
+	AssertEqual(t, "agent", topic.ID)
+}
+
+func TestAX7_ParseTopic_Bad(t *T) {
+	topic, err := ParseTopic("bad.md", []byte("---\n: bad\n---\n# Bad\n"))
+	RequireNoError(t, err)
+	AssertEqual(t, "Bad", topic.Title)
+	AssertContains(t, topic.Content, "---")
+}
+
+func TestAX7_ParseTopic_Ugly(t *T) {
+	topic, err := ParseTopic("empty.md", nil)
+	RequireNoError(t, err)
+	AssertEqual(t, "empty", topic.ID)
+	AssertEmpty(t, topic.Sections)
+}
+
+func TestAX7_ExtractFrontmatter_Good(t *T) {
+	fm, body := ExtractFrontmatter("---\ntitle: Agent\norder: 2\n---\n# Body")
+	RequireNotEmpty(t, body)
+	AssertNotNil(t, fm)
+	AssertEqual(t, "Agent", fm.Title)
+}
+
+func TestAX7_ExtractFrontmatter_Bad(t *T) {
+	content := "---\n: bad\n---\n# Body"
+	fm, body := ExtractFrontmatter(content)
+	AssertNil(t, fm)
+	AssertEqual(t, content, body)
+}
+
+func TestAX7_ExtractFrontmatter_Ugly(t *T) {
+	fm, body := ExtractFrontmatter("---\r\n\r\n---\r\n# Body")
+	AssertNotNil(t, fm)
+	AssertEqual(t, "", fm.Title)
+	AssertContains(t, body, "# Body")
+}
+
+func TestAX7_ExtractSections_Good(t *T) {
+	sections := ExtractSections("# Agent\n\nIntro\n## Run\n\nSteps")
+	AssertLen(t, sections, 2)
+	AssertEqual(t, "agent", sections[0].ID)
+	AssertContains(t, sections[1].Content, "Steps")
+}
+
+func TestAX7_ExtractSections_Bad(t *T) {
+	sections := ExtractSections("No markdown heading here.")
+	AssertEmpty(t, sections)
+	AssertLen(t, sections, 0)
+	AssertFalse(t, len(sections) > 0)
+}
+
+func TestAX7_ExtractSections_Ugly(t *T) {
+	sections := ExtractSections("# One\n## Two\n### Three")
+	AssertLen(t, sections, 3)
+	AssertEqual(t, "", sections[0].Content)
+	AssertEqual(t, "", sections[1].Content)
+}
+
+func TestAX7_AllSections_Good(t *T) {
+	sections := slices.Collect(AllSections("# Agent\n\nIntro\n## Run\n\nSteps"))
+	AssertLen(t, sections, 2)
+	AssertEqual(t, "Agent", sections[0].Title)
+	AssertEqual(t, "Run", sections[1].Title)
+}
+
+func TestAX7_AllSections_Bad(t *T) {
+	sections := slices.Collect(AllSections("plain text"))
+	AssertEmpty(t, sections)
+	AssertLen(t, sections, 0)
+	AssertFalse(t, len(sections) > 0)
+}
+
+func TestAX7_AllSections_Ugly(t *T) {
+	count := 0
+	for section := range AllSections("# One\n## Two") {
+		AssertEqual(t, "One", section.Title)
+		count++
+		break
+	}
+	AssertEqual(t, 1, count)
+}
+
+func TestAX7_GenerateID_Good(t *T) {
+	id := GenerateID("Agent Guide")
+	AssertEqual(t, "agent-guide", id)
+	AssertNotContains(t, id, " ")
+	AssertContains(t, id, "-")
+}
+
+func TestAX7_GenerateID_Bad(t *T) {
+	id := GenerateID("!@#$%^&*()")
+	AssertEqual(t, "", id)
+	AssertEmpty(t, id)
+	AssertNotContains(t, id, "-")
+}
+
+func TestAX7_GenerateID_Ugly(t *T) {
+	id := GenerateID("日本語 Agent 🚀")
+	AssertContains(t, id, "日本語")
+	AssertContains(t, id, "agent")
+	AssertNotContains(t, id, "🚀")
+}
+
+func TestAX7_RenderIndexPage_Good(t *T) {
+	html := RenderIndexPage(ax7Catalog().List())
+	AssertContains(t, html, `role="banner"`)
+	AssertContains(t, html, "Agent Guide")
+	AssertContains(t, html, `role="main"`)
+}
+
+func TestAX7_RenderIndexPage_Bad(t *T) {
+	html := RenderIndexPage(nil)
+	AssertContains(t, html, "No topics available")
+	AssertContains(t, html, `0 topics`)
+	AssertContains(t, html, `role="contentinfo"`)
+}
+
+func TestAX7_RenderIndexPage_Ugly(t *T) {
+	html := RenderIndexPage([]*Topic{{ID: "x", Title: `<script>alert("x")</script>`, Content: "safe"}})
+	AssertNotContains(t, html, `<script>alert`)
+	AssertContains(t, html, "&lt;script&gt;")
+	AssertContains(t, html, "safe")
+}
+
+func TestAX7_RenderTopicPage_Good(t *T) {
+	html := RenderTopicPage(ax7Topic(), ax7Catalog().List())
+	AssertContains(t, html, `role="complementary"`)
+	AssertContains(t, html, "<strong>")
+	AssertContains(t, html, "Agent Guide")
+}
+
+func TestAX7_RenderTopicPage_Bad(t *T) {
+	html := RenderTopicPage(&Topic{ID: "solo", Title: "Solo", Content: "Plain content."}, nil)
+	AssertContains(t, html, `role="main"`)
+	AssertNotContains(t, html, `role="complementary"`)
+	AssertContains(t, html, "Plain content")
+}
+
+func TestAX7_RenderTopicPage_Ugly(t *T) {
+	html := RenderTopicPage(&Topic{ID: "edge", Title: `<script>`, Content: "Edge content."}, nil)
+	AssertNotContains(t, html, `<script>`)
+	AssertContains(t, html, "Edge content")
+	AssertContains(t, html, `role="banner"`)
+}
+
+func TestAX7_RenderSearchPage_Good(t *T) {
+	result := &SearchResult{Topic: ax7Topic(), Score: 12.5, Snippet: "Run the **agent**."}
+	html := RenderSearchPage("agent", []*SearchResult{result})
+	AssertContains(t, html, "Agent Guide")
+	AssertContains(t, html, "12.5")
+}
+
+func TestAX7_RenderSearchPage_Bad(t *T) {
+	html := RenderSearchPage("missing", nil)
+	AssertContains(t, html, "No results")
+	AssertContains(t, html, "missing")
+	AssertContains(t, html, `role="main"`)
+}
+
+func TestAX7_RenderSearchPage_Ugly(t *T) {
+	html := RenderSearchPage(`<agent>`, nil)
+	AssertNotContains(t, html, `<agent>`)
+	AssertContains(t, html, "&lt;agent&gt;")
+	AssertContains(t, html, `role="banner"`)
+}
+
+func TestAX7_Render404Page_Good(t *T) {
+	html := Render404Page()
+	AssertContains(t, html, "404")
+	AssertContains(t, html, "Not Found")
+	AssertContains(t, html, `role="main"`)
+}
+
+func TestAX7_Render404Page_Bad(t *T) {
+	html := Render404Page()
+	AssertContains(t, html, "Browse all topics")
+	AssertContains(t, html, `role="contentinfo"`)
+	AssertNotContains(t, html, "No results")
+}
+
+func TestAX7_Render404Page_Ugly(t *T) {
+	html := Render404Page()
+	AssertContains(t, html, "<!DOCTYPE html>")
+	AssertContains(t, html, `role="banner"`)
+	AssertContains(t, html, `href="/"`)
+}
+
+func TestAX7_Index_Add_Good(t *T) {
+	idx := newSearchIndex()
+	idx.Add(ax7Topic())
+	AssertNotNil(t, idx.topics["agent-guide"])
+	AssertContains(t, idx.index["agent"], "agent-guide")
+}
+
+func TestAX7_Index_Add_Bad(t *T) {
+	idx := newSearchIndex()
+	idx.Add(&Topic{ID: "repeat", Title: "Repeat Repeat"})
+	AssertLen(t, idx.index["repeat"], 1)
+	AssertEqual(t, "Repeat Repeat", idx.topics["repeat"].Title)
+}
+
+func TestAX7_Index_Add_Ugly(t *T) {
+	idx := newSearchIndex()
+	idx.Add(&Topic{ID: "", Title: "Empty", Content: "edge"})
+	AssertNotNil(t, idx.topics[""])
+	AssertContains(t, idx.index["empty"], "")
+}
+
+func TestAX7_Index_Search_Good(t *T) {
+	idx := newSearchIndex()
+	idx.Add(ax7Topic())
+	results := idx.Search("agent")
+	AssertNotEmpty(t, results)
+	AssertEqual(t, "agent-guide", results[0].Topic.ID)
+}
+
+func TestAX7_Index_Search_Bad(t *T) {
+	idx := newSearchIndex()
+	results := idx.Search("")
+	AssertNil(t, results)
+	AssertNotNil(t, idx.index)
+}
+
+func TestAX7_Index_Search_Ugly(t *T) {
+	idx := newSearchIndex()
+	idx.topics["ghost"] = nil
+	idx.index["ghost"] = []string{"ghost"}
+	results := idx.Search("ghost")
+	AssertEmpty(t, results)
+}
+
+func TestAX7_Tokens_Good(t *T) {
+	tokens := slices.Collect(Tokens("Hello, agent world!"))
+	AssertEqual(t, []string{"hello", "agent", "world"}, tokens)
+	AssertContains(t, tokens, "agent")
+	AssertNotContains(t, tokens, "!")
+}
+
+func TestAX7_Tokens_Bad(t *T) {
+	tokens := slices.Collect(Tokens("a b c"))
+	AssertEmpty(t, tokens)
+	AssertLen(t, tokens, 0)
+	AssertFalse(t, len(tokens) > 0)
+}
+
+func TestAX7_Tokens_Ugly(t *T) {
+	tokens := slices.Collect(Tokens("running"))
+	AssertContains(t, tokens, "running")
+	AssertContains(t, tokens, "runn")
+	AssertLen(t, tokens, 2)
+}
diff --git a/pkg/help/catalog.go b/pkg/help/catalog.go
index 349dc26..fe201c5 100644
--- a/pkg/help/catalog.go
+++ b/pkg/help/catalog.go
@@ -1,6 +1,7 @@
 package help
 
 import (
+	"fmt"
 	"io/fs"
 	"iter"
 	"maps"
@@ -8,8 +9,6 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
-
-	log "forge.lthn.ai/core/go-log"
 )
 
 // Catalog manages help topics.
@@ -115,19 +114,19 @@ func LoadContentDir(dir string) (*Catalog, error) {
 
 		content, err := os.ReadFile(path)
 		if err != nil {
-			return log.E("catalog.LoadContentDir", "reading "+path, err)
+			return fmt.Errorf("catalog.LoadContentDir: reading %s: %w", path, err)
 		}
 
 		topic, err := ParseTopic(path, content)
 		if err != nil {
-			return log.E("catalog.LoadContentDir", "parsing "+path, err)
+			return fmt.Errorf("catalog.LoadContentDir: parsing %s: %w", path, err)
 		}
 
 		c.Add(topic)
 		return nil
 	})
 	if err != nil {
-		return nil, log.E("catalog.LoadContentDir", "walking directory "+dir, err)
+		return nil, fmt.Errorf("catalog.LoadContentDir: walking directory %s: %w", dir, err)
 	}
 
 	return c, nil
@@ -137,7 +136,7 @@ func LoadContentDir(dir string) (*Catalog, error) {
 func (c *Catalog) Get(id string) (*Topic, error) {
 	t, ok := c.topics[id]
 	if !ok {
-		return nil, log.E("catalog.Get", "topic not found: "+id, nil)
+		return nil, fmt.Errorf("catalog.Get: topic not found: %s", id)
 	}
 	return t, nil
 }
diff --git a/pkg/help/catalog_test.go b/pkg/help/catalog_test.go
index 568038d..2fa51d2 100644
--- a/pkg/help/catalog_test.go
+++ b/pkg/help/catalog_test.go
@@ -1,43 +1,40 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"fmt"
 	"os"
 	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestDefaultCatalog_Good(t *testing.T) {
+func TestDefaultCatalog_Good(t *T) {
 	c := DefaultCatalog()
 
-	require.NotNil(t, c)
-	require.NotNil(t, c.topics)
-	require.NotNil(t, c.index)
+	AssertNotNil(t, c)
+	AssertNotNil(t, c.topics)
+	AssertNotNil(t, c.index)
 
-	t.Run("contains built-in topics", func(t *testing.T) {
+	t.Run("contains built-in topics", func(t *T) {
 		topics := c.List()
-		assert.GreaterOrEqual(t, len(topics), 2, "should have at least 2 default topics")
+		AssertGreaterOrEqual(t, len(topics), 2, "should have at least 2 default topics")
 	})
 
-	t.Run("getting-started topic exists", func(t *testing.T) {
+	t.Run("getting-started topic exists", func(t *T) {
 		topic, err := c.Get("getting-started")
-		require.NoError(t, err)
-		assert.Equal(t, "Getting Started", topic.Title)
-		assert.Contains(t, topic.Content, "Common Commands")
+		RequireNoError(t, err)
+		AssertEqual(t, "Getting Started", topic.Title)
+		AssertContains(t, topic.Content, "Common Commands")
 	})
 
-	t.Run("config topic exists", func(t *testing.T) {
+	t.Run("config topic exists", func(t *T) {
 		topic, err := c.Get("config")
-		require.NoError(t, err)
-		assert.Equal(t, "Configuration", topic.Title)
-		assert.Contains(t, topic.Content, "Environment Variables")
+		RequireNoError(t, err)
+		AssertEqual(t, "Configuration", topic.Title)
+		AssertContains(t, topic.Content, "Environment Variables")
 	})
 }
 
-func TestCatalog_Add_Good(t *testing.T) {
+func TestCatalog_Add_Good(t *T) {
 	c := &Catalog{
 		topics: make(map[string]*Topic),
 		index:  newSearchIndex(),
@@ -52,18 +49,18 @@ func TestCatalog_Add_Good(t *testing.T) {
 
 	c.Add(topic)
 
-	t.Run("topic is retrievable after add", func(t *testing.T) {
+	t.Run("topic is retrievable after add", func(t *T) {
 		got, err := c.Get("test-topic")
-		require.NoError(t, err)
-		assert.Equal(t, topic, got)
+		RequireNoError(t, err)
+		AssertEqual(t, topic, got)
 	})
 
-	t.Run("topic is searchable after add", func(t *testing.T) {
+	t.Run("topic is searchable after add", func(t *T) {
 		results := c.Search("test")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 	})
 
-	t.Run("overwrite existing topic", func(t *testing.T) {
+	t.Run("overwrite existing topic", func(t *T) {
 		replacement := &Topic{
 			ID:      "test-topic",
 			Title:   "Replaced Topic",
@@ -72,61 +69,61 @@ func TestCatalog_Add_Good(t *testing.T) {
 		c.Add(replacement)
 
 		got, err := c.Get("test-topic")
-		require.NoError(t, err)
-		assert.Equal(t, "Replaced Topic", got.Title)
+		RequireNoError(t, err)
+		AssertEqual(t, "Replaced Topic", got.Title)
 	})
 }
 
-func TestCatalog_List_Good(t *testing.T) {
+func TestCatalog_List_Good(t *T) {
 	c := &Catalog{
 		topics: make(map[string]*Topic),
 		index:  newSearchIndex(),
 	}
 
-	t.Run("empty catalog returns empty list", func(t *testing.T) {
+	t.Run("empty catalog returns empty list", func(t *T) {
 		list := c.List()
-		assert.Empty(t, list)
+		AssertEmpty(t, list)
 	})
 
-	t.Run("returns all added topics", func(t *testing.T) {
+	t.Run("returns all added topics", func(t *T) {
 		c.Add(&Topic{ID: "alpha", Title: "Alpha"})
 		c.Add(&Topic{ID: "beta", Title: "Beta"})
 		c.Add(&Topic{ID: "gamma", Title: "Gamma"})
 
 		list := c.List()
-		assert.Len(t, list, 3)
+		AssertLen(t, list, 3)
 
 		// Collect IDs (order is not guaranteed from map)
 		ids := make(map[string]bool)
 		for _, t := range list {
 			ids[t.ID] = true
 		}
-		assert.True(t, ids["alpha"])
-		assert.True(t, ids["beta"])
-		assert.True(t, ids["gamma"])
+		AssertTrue(t, ids["alpha"])
+		AssertTrue(t, ids["beta"])
+		AssertTrue(t, ids["gamma"])
 	})
 }
 
-func TestCatalog_Search_Good(t *testing.T) {
+func TestCatalog_Search_Good(t *T) {
 	c := DefaultCatalog()
 
-	t.Run("finds default topics", func(t *testing.T) {
+	t.Run("finds default topics", func(t *T) {
 		results := c.Search("configuration")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 	})
 
-	t.Run("empty query returns nil", func(t *testing.T) {
+	t.Run("empty query returns nil", func(t *T) {
 		results := c.Search("")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 
-	t.Run("no match returns empty", func(t *testing.T) {
+	t.Run("no match returns empty", func(t *T) {
 		results := c.Search("zzzyyyxxx")
-		assert.Empty(t, results)
+		AssertEmpty(t, results)
 	})
 }
 
-func TestCatalog_Get_Good(t *testing.T) {
+func TestCatalog_Get_Good(t *T) {
 	c := &Catalog{
 		topics: make(map[string]*Topic),
 		index:  newSearchIndex(),
@@ -134,22 +131,22 @@ func TestCatalog_Get_Good(t *testing.T) {
 
 	c.Add(&Topic{ID: "exists", Title: "Existing Topic"})
 
-	t.Run("existing topic", func(t *testing.T) {
+	t.Run("existing topic", func(t *T) {
 		topic, err := c.Get("exists")
-		require.NoError(t, err)
-		assert.Equal(t, "Existing Topic", topic.Title)
+		RequireNoError(t, err)
+		AssertEqual(t, "Existing Topic", topic.Title)
 	})
 
-	t.Run("missing topic returns error", func(t *testing.T) {
+	t.Run("missing topic returns error", func(t *T) {
 		topic, err := c.Get("does-not-exist")
-		assert.Nil(t, topic)
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "topic not found")
-		assert.Contains(t, err.Error(), "does-not-exist")
+		AssertNil(t, topic)
+		AssertError(t, err)
+		AssertContains(t, err.Error(), "topic not found")
+		AssertContains(t, err.Error(), "does-not-exist")
 	})
 }
 
-func TestCatalog_Search_Good_ScoreTiebreaking(t *testing.T) {
+func TestCatalog_Search_Good_ScoreTiebreaking(t *T) {
 	// Tests the alphabetical tie-breaking in search result sorting (search.go:165).
 	c := &Catalog{
 		topics: make(map[string]*Topic),
@@ -169,52 +166,52 @@ func TestCatalog_Search_Good_ScoreTiebreaking(t *testing.T) {
 	})
 
 	results := c.Search("zephyr")
-	require.Len(t, results, 2)
+	AssertLen(t, results, 2)
 
 	// With equal scores, results should be sorted alphabetically by title.
-	assert.Equal(t, "Alpha", results[0].Topic.Title)
-	assert.Equal(t, "Zebra", results[1].Topic.Title)
-	assert.Equal(t, results[0].Score, results[1].Score,
+	AssertEqual(t, "Alpha", results[0].Topic.Title)
+	AssertEqual(t, "Zebra", results[1].Topic.Title)
+	AssertEqual(t, results[0].Score, results[1].Score,
 		"scores should be equal for tie-breaking to apply")
 }
 
-func TestCatalog_LoadContentDir_Good(t *testing.T) {
+func TestCatalog_LoadContentDir_Good(t *T) {
 	dir := t.TempDir()
 	os.MkdirAll(filepath.Join(dir, "cli"), 0o755)
 	os.WriteFile(filepath.Join(dir, "cli", "dev-work.md"), []byte("---\ntitle: Dev Work\ntags: [cli, dev]\n---\n\n## Usage\n\ncore dev work syncs your workspace.\n"), 0o644)
 	os.WriteFile(filepath.Join(dir, "cli", "setup.md"), []byte("---\ntitle: Setup\ntags: [cli]\n---\n\n## Installation\n\nRun core setup to get started.\n"), 0o644)
 
 	catalog, err := LoadContentDir(dir)
-	require.NoError(t, err)
-	assert.Len(t, catalog.List(), 2)
+	RequireNoError(t, err)
+	AssertLen(t, catalog.List(), 2)
 
 	devWork, err := catalog.Get("dev-work")
-	require.NoError(t, err)
-	assert.Equal(t, "Dev Work", devWork.Title)
-	assert.Contains(t, devWork.Tags, "cli")
+	RequireNoError(t, err)
+	AssertEqual(t, "Dev Work", devWork.Title)
+	AssertContains(t, devWork.Tags, "cli")
 
 	results := catalog.Search("workspace")
-	assert.NotEmpty(t, results)
+	AssertNotEmpty(t, results)
 }
 
-func TestCatalog_LoadContentDir_Good_Empty(t *testing.T) {
+func TestCatalog_LoadContentDir_Good_Empty(t *T) {
 	dir := t.TempDir()
 	catalog, err := LoadContentDir(dir)
-	require.NoError(t, err)
-	assert.Empty(t, catalog.List())
+	RequireNoError(t, err)
+	AssertEmpty(t, catalog.List())
 }
 
-func TestCatalog_LoadContentDir_Good_SkipsNonMd(t *testing.T) {
+func TestCatalog_LoadContentDir_Good_SkipsNonMd(t *T) {
 	dir := t.TempDir()
 	os.WriteFile(filepath.Join(dir, "readme.txt"), []byte("not markdown"), 0o644)
 	os.WriteFile(filepath.Join(dir, "topic.md"), []byte("---\ntitle: Topic\n---\n\nContent here.\n"), 0o644)
 
 	catalog, err := LoadContentDir(dir)
-	require.NoError(t, err)
-	assert.Len(t, catalog.List(), 1)
+	RequireNoError(t, err)
+	AssertLen(t, catalog.List(), 1)
 }
 
-func BenchmarkSearch(b *testing.B) {
+func BenchmarkSearch(b *B) {
 	// Build a catalog with 100+ topics for benchmarking.
 	c := &Catalog{
 		topics: make(map[string]*Topic),
diff --git a/pkg/help/generate_test.go b/pkg/help/generate_test.go
index 4a8b900..b6ce1bc 100644
--- a/pkg/help/generate_test.go
+++ b/pkg/help/generate_test.go
@@ -2,13 +2,10 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"encoding/json"
 	"os"
 	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 // testCatalog builds a small catalog for generator tests.
@@ -36,12 +33,12 @@ func testCatalog() *Catalog {
 	return c
 }
 
-func TestGenerate_Good_FileStructure(t *testing.T) {
+func TestGenerate_Good_FileStructure(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	// Verify expected file structure
 	expectedFiles := []string{
@@ -56,123 +53,123 @@ func TestGenerate_Good_FileStructure(t *testing.T) {
 	for _, f := range expectedFiles {
 		path := filepath.Join(dir, f)
 		_, err := os.Stat(path)
-		assert.NoError(t, err, "expected file %s to exist", f)
+		AssertNoError(t, err, "expected generated file to exist: "+f)
 	}
 }
 
-func TestGenerate_Good_IndexContainsTopics(t *testing.T) {
+func TestGenerate_Good_IndexContainsTopics(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	content, err := os.ReadFile(filepath.Join(dir, "index.html"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	html := string(content)
-	assert.Contains(t, html, "Getting Started")
-	assert.Contains(t, html, "Configuration")
+	AssertContains(t, html, "Getting Started")
+	AssertContains(t, html, "Configuration")
 }
 
-func TestGenerate_Good_TopicContainsRenderedMarkdown(t *testing.T) {
+func TestGenerate_Good_TopicContainsRenderedMarkdown(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	content, err := os.ReadFile(filepath.Join(dir, "topics", "getting-started.html"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	html := string(content)
-	assert.Contains(t, html, "Getting Started")
-	assert.Contains(t, html, "<strong>guide</strong>")
+	AssertContains(t, html, "Getting Started")
+	AssertContains(t, html, "<strong>guide</strong>")
 }
 
-func TestGenerate_Good_SearchIndexJSON(t *testing.T) {
+func TestGenerate_Good_SearchIndexJSON(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	content, err := os.ReadFile(filepath.Join(dir, "search-index.json"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	var entries []searchIndexEntry
-	require.NoError(t, json.Unmarshal(content, &entries))
-	assert.Len(t, entries, 2, "search index should contain all topics")
+	RequireNoError(t, json.Unmarshal(content, &entries))
+	AssertLen(t, entries, 2, "search index should contain all topics")
 
 	// Verify fields are populated
 	ids := make(map[string]bool)
 	for _, e := range entries {
 		ids[e.ID] = true
-		assert.NotEmpty(t, e.Title)
-		assert.NotEmpty(t, e.Content)
+		AssertNotEmpty(t, e.Title)
+		AssertNotEmpty(t, e.Content)
 	}
-	assert.True(t, ids["getting-started"])
-	assert.True(t, ids["config"])
+	AssertTrue(t, ids["getting-started"])
+	AssertTrue(t, ids["config"])
 }
 
-func TestGenerate_Good_404Exists(t *testing.T) {
+func TestGenerate_Good_404Exists(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	content, err := os.ReadFile(filepath.Join(dir, "404.html"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	html := string(content)
-	assert.Contains(t, html, "404")
-	assert.Contains(t, html, "Not Found")
+	AssertContains(t, html, "404")
+	AssertContains(t, html, "Not Found")
 }
 
-func TestGenerate_Good_EmptyDir(t *testing.T) {
+func TestGenerate_Good_EmptyDir(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	// Should succeed in an empty directory
 	err := Generate(catalog, dir)
-	assert.NoError(t, err)
+	AssertNoError(t, err)
 }
 
-func TestGenerate_Good_OverwriteExisting(t *testing.T) {
+func TestGenerate_Good_OverwriteExisting(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	// Generate once
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	// Generate again -- should overwrite without error
 	err = Generate(catalog, dir)
-	assert.NoError(t, err)
+	AssertNoError(t, err)
 
 	// Verify files still exist and are valid
 	content, err := os.ReadFile(filepath.Join(dir, "index.html"))
-	require.NoError(t, err)
-	assert.Contains(t, string(content), "Getting Started")
+	RequireNoError(t, err)
+	AssertContains(t, string(content), "Getting Started")
 }
 
-func TestGenerate_Good_SearchPageHasScript(t *testing.T) {
+func TestGenerate_Good_SearchPageHasScript(t *T) {
 	dir := t.TempDir()
 	catalog := testCatalog()
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	content, err := os.ReadFile(filepath.Join(dir, "search.html"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	html := string(content)
-	assert.Contains(t, html, "<script>")
-	assert.Contains(t, html, "search-index.json")
+	AssertContains(t, html, "<script>")
+	AssertContains(t, html, "search-index.json")
 }
 
-func TestGenerate_Good_EmptyCatalog(t *testing.T) {
+func TestGenerate_Good_EmptyCatalog(t *T) {
 	dir := t.TempDir()
 	catalog := &Catalog{
 		topics: make(map[string]*Topic),
@@ -180,16 +177,16 @@ func TestGenerate_Good_EmptyCatalog(t *testing.T) {
 	}
 
 	err := Generate(catalog, dir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	// index.html should still exist
 	_, err = os.Stat(filepath.Join(dir, "index.html"))
-	assert.NoError(t, err)
+	AssertNoError(t, err)
 
 	// search-index.json should be valid empty array
 	content, err := os.ReadFile(filepath.Join(dir, "search-index.json"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	var entries []searchIndexEntry
-	require.NoError(t, json.Unmarshal(content, &entries))
-	assert.Empty(t, entries)
+	RequireNoError(t, json.Unmarshal(content, &entries))
+	AssertEmpty(t, entries)
 }
diff --git a/pkg/help/ingest_test.go b/pkg/help/ingest_test.go
index a1eb486..560cc72 100644
--- a/pkg/help/ingest_test.go
+++ b/pkg/help/ingest_test.go
@@ -2,13 +2,10 @@
 package help
 
 import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	. "dappco.re/go"
 )
 
-func TestParseHelpText_Good_StandardGoFlags(t *testing.T) {
+func TestParseHelpText_Good_StandardGoFlags(t *T) {
 	helpText := `Core development workflow tool.
 
 Usage:
@@ -22,17 +19,17 @@ Flags:
 
 	topic := ParseHelpText("dev", helpText)
 
-	assert.Equal(t, "dev", topic.ID)
-	assert.Equal(t, "Dev", topic.Title)
-	assert.Contains(t, topic.Content, "## Usage")
-	assert.Contains(t, topic.Content, "core dev [command]")
-	assert.Contains(t, topic.Content, "## Flags")
-	assert.Contains(t, topic.Content, "--help")
-	assert.Contains(t, topic.Content, "--verbose")
-	assert.Equal(t, []string{"cli", "dev"}, topic.Tags)
+	AssertEqual(t, "dev", topic.ID)
+	AssertEqual(t, "Dev", topic.Title)
+	AssertContains(t, topic.Content, "## Usage")
+	AssertContains(t, topic.Content, "core dev [command]")
+	AssertContains(t, topic.Content, "## Flags")
+	AssertContains(t, topic.Content, "--help")
+	AssertContains(t, topic.Content, "--verbose")
+	AssertEqual(t, []string{"cli", "dev"}, topic.Tags)
 }
 
-func TestParseHelpText_Good_CobraStyleSubcommands(t *testing.T) {
+func TestParseHelpText_Good_CobraStyleSubcommands(t *T) {
 	helpText := `Manage repository operations
 
 Usage:
@@ -51,26 +48,26 @@ Flags:
 
 	topic := ParseHelpText("dev", helpText)
 
-	assert.Contains(t, topic.Content, "## Commands")
-	assert.Contains(t, topic.Content, "**commit**")
-	assert.Contains(t, topic.Content, "**push**")
-	assert.Contains(t, topic.Content, "**pull**")
-	assert.Contains(t, topic.Content, "**status**")
-	assert.Contains(t, topic.Content, "## Flags")
+	AssertContains(t, topic.Content, "## Commands")
+	AssertContains(t, topic.Content, "**commit**")
+	AssertContains(t, topic.Content, "**push**")
+	AssertContains(t, topic.Content, "**pull**")
+	AssertContains(t, topic.Content, "**status**")
+	AssertContains(t, topic.Content, "## Flags")
 }
 
-func TestParseHelpText_Good_MinimalHelpText(t *testing.T) {
+func TestParseHelpText_Good_MinimalHelpText(t *T) {
 	helpText := "Show the current version."
 
 	topic := ParseHelpText("version", helpText)
 
-	assert.Equal(t, "version", topic.ID)
-	assert.Equal(t, "Version", topic.Title)
-	assert.Contains(t, topic.Content, "Show the current version.")
-	assert.Equal(t, []string{"cli", "version"}, topic.Tags)
+	AssertEqual(t, "version", topic.ID)
+	AssertEqual(t, "Version", topic.Title)
+	AssertContains(t, topic.Content, "Show the current version.")
+	AssertEqual(t, []string{"cli", "version"}, topic.Tags)
 }
 
-func TestParseHelpText_Good_WithExamples(t *testing.T) {
+func TestParseHelpText_Good_WithExamples(t *T) {
 	helpText := `Commit changes across repositories.
 
 Usage:
@@ -88,15 +85,15 @@ Flags:
 
 	topic := ParseHelpText("dev commit", helpText)
 
-	assert.Equal(t, "dev-commit", topic.ID)
-	assert.Equal(t, "Dev Commit", topic.Title)
-	assert.Contains(t, topic.Content, "## Examples")
-	assert.Contains(t, topic.Content, "core dev commit --all")
-	assert.Contains(t, topic.Content, `core dev commit -m "fix: resolve bug"`)
-	assert.Equal(t, []string{"cli", "dev"}, topic.Tags)
+	AssertEqual(t, "dev-commit", topic.ID)
+	AssertEqual(t, "Dev Commit", topic.Title)
+	AssertContains(t, topic.Content, "## Examples")
+	AssertContains(t, topic.Content, "core dev commit --all")
+	AssertContains(t, topic.Content, `core dev commit -m "fix: resolve bug"`)
+	AssertEqual(t, []string{"cli", "dev"}, topic.Tags)
 }
 
-func TestIngestCLIHelp_Good_BatchIngest(t *testing.T) {
+func TestIngestCLIHelp_Good_BatchIngest(t *T) {
 	helpTexts := map[string]string{
 		"dev":        "Development workflow tool.\n\nUsage:\n  core dev [command]\n",
 		"dev commit": "Commit changes.\n\nUsage:\n  core dev commit [flags]\n",
@@ -105,30 +102,30 @@ func TestIngestCLIHelp_Good_BatchIngest(t *testing.T) {
 
 	catalog := IngestCLIHelp(helpTexts)
 
-	assert.NotNil(t, catalog)
+	AssertNotNil(t, catalog)
 
 	topics := catalog.List()
-	assert.Len(t, topics, 3)
+	AssertLen(t, topics, 3)
 
 	// Verify specific topics
 	devTopic, err := catalog.Get("dev")
-	require.NoError(t, err)
-	assert.Equal(t, "Dev", devTopic.Title)
+	RequireNoError(t, err)
+	AssertEqual(t, "Dev", devTopic.Title)
 
 	commitTopic, err := catalog.Get("dev-commit")
-	require.NoError(t, err)
-	assert.Equal(t, "Dev Commit", commitTopic.Title)
+	RequireNoError(t, err)
+	AssertEqual(t, "Dev Commit", commitTopic.Title)
 
 	pushTopic, err := catalog.Get("dev-push")
-	require.NoError(t, err)
-	assert.Equal(t, "Dev Push", pushTopic.Title)
+	RequireNoError(t, err)
+	AssertEqual(t, "Dev Push", pushTopic.Title)
 
 	// All should be searchable
 	results := catalog.Search("commit")
-	assert.NotEmpty(t, results)
+	AssertNotEmpty(t, results)
 }
 
-func TestParseHelpText_Good_SeeAlso(t *testing.T) {
+func TestParseHelpText_Good_SeeAlso(t *T) {
 	helpText := `Push commits to remote repositories.
 
 Usage:
@@ -140,23 +137,23 @@ See also: dev commit, dev pull
 
 	topic := ParseHelpText("dev push", helpText)
 
-	assert.Equal(t, "dev-push", topic.ID)
-	assert.Equal(t, []string{"dev-commit", "dev-pull"}, topic.Related)
+	AssertEqual(t, "dev-push", topic.ID)
+	AssertEqual(t, []string{"dev-commit", "dev-pull"}, topic.Related)
 	// "See also" line should be removed from content
-	assert.NotContains(t, topic.Content, "See also")
+	AssertNotContains(t, topic.Content, "See also")
 }
 
-func TestParseHelpText_Good_EmptyHelpText(t *testing.T) {
+func TestParseHelpText_Good_EmptyHelpText(t *T) {
 	topic := ParseHelpText("empty", "")
 
-	assert.Equal(t, "empty", topic.ID)
-	assert.Equal(t, "Empty", topic.Title)
-	assert.Equal(t, "", topic.Content)
-	assert.Equal(t, []string{"cli", "empty"}, topic.Tags)
-	assert.Empty(t, topic.Sections)
+	AssertEqual(t, "empty", topic.ID)
+	AssertEqual(t, "Empty", topic.Title)
+	AssertEqual(t, "", topic.Content)
+	AssertEqual(t, []string{"cli", "empty"}, topic.Tags)
+	AssertEmpty(t, topic.Sections)
 }
 
-func TestParseHelpText_Good_OptionsSection(t *testing.T) {
+func TestParseHelpText_Good_OptionsSection(t *T) {
 	// Some tools use "Options:" instead of "Flags:"
 	helpText := `Run tests across repositories.
 
@@ -167,11 +164,11 @@ Options:
 `
 
 	topic := ParseHelpText("test", helpText)
-	assert.Contains(t, topic.Content, "## Flags") // Options: mapped to ## Flags
-	assert.Contains(t, topic.Content, "--filter")
+	AssertContains(t, topic.Content, "## Flags") // Options: mapped to ## Flags
+	AssertContains(t, topic.Content, "--filter")
 }
 
-func TestTitleCaseWords_Good(t *testing.T) {
+func TestTitleCaseWords_Good(t *T) {
 	tests := []struct {
 		input    string
 		expected string
@@ -184,31 +181,31 @@ func TestTitleCaseWords_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			assert.Equal(t, tt.expected, titleCaseWords(tt.input))
+		t.Run(tt.input, func(t *T) {
+			AssertEqual(t, tt.expected, titleCaseWords(tt.input))
 		})
 	}
 }
 
-func TestExtractSeeAlso_Good(t *testing.T) {
-	t.Run("with see also line", func(t *testing.T) {
+func TestExtractSeeAlso_Good(t *T) {
+	t.Run("with see also line", func(t *T) {
 		text := "Some content.\nSee also: dev commit, dev pull\nMore content."
 		related, cleaned := extractSeeAlso(text)
-		assert.Equal(t, []string{"dev-commit", "dev-pull"}, related)
-		assert.NotContains(t, cleaned, "See also")
-		assert.Contains(t, cleaned, "Some content.")
-		assert.Contains(t, cleaned, "More content.")
+		AssertEqual(t, []string{"dev-commit", "dev-pull"}, related)
+		AssertNotContains(t, cleaned, "See also")
+		AssertContains(t, cleaned, "Some content.")
+		AssertContains(t, cleaned, "More content.")
 	})
 
-	t.Run("no see also", func(t *testing.T) {
+	t.Run("no see also", func(t *T) {
 		text := "Just normal content."
 		related, cleaned := extractSeeAlso(text)
-		assert.Empty(t, related)
-		assert.Equal(t, text, cleaned)
+		AssertEmpty(t, related)
+		AssertEqual(t, text, cleaned)
 	})
 }
 
-func TestParseHelpText_Good_MultiLineDescription(t *testing.T) {
+func TestParseHelpText_Good_MultiLineDescription(t *T) {
 	helpText := `Core is a multi-repository management tool that helps you
 manage development workflows across federated monorepos.
 
@@ -221,18 +218,20 @@ Usage:
 `
 
 	topic := ParseHelpText("core", helpText)
-	assert.Contains(t, topic.Content, "multi-repository management")
-	assert.Contains(t, topic.Content, "## Usage")
+	AssertContains(t, topic.Content, "multi-repository management")
+	AssertContains(t, topic.Content, "## Usage")
 }
 
-func TestParseHelpText_Good_CLINameDoesNotDuplicateTag(t *testing.T) {
+func TestParseHelpText_Good_CLINameDoesNotDuplicateTag(t *T) {
 	// When the command name starts with "cli", the tag list should
 	// not contain "cli" twice.
 	topic := ParseHelpText("cli", "CLI root command.")
-	assert.Equal(t, []string{"cli"}, topic.Tags)
+	AssertEqual(t, "cli", topic.ID)
+	AssertEqual(t, []string{"cli"}, topic.Tags)
+	AssertEqual(t, "Cli", topic.Title)
 }
 
-func TestParseHelpText_Good_CodeBlockEndedByNewSection(t *testing.T) {
+func TestParseHelpText_Good_CodeBlockEndedByNewSection(t *T) {
 	// Tests the endsCodeBlockSection path: a code block for Usage is
 	// terminated when a Flags section starts on a non-indented line.
 	helpText := `Usage:
@@ -242,36 +241,36 @@ Flags:
 
 `
 	topic := ParseHelpText("run", helpText)
-	assert.Contains(t, topic.Content, "## Usage")
-	assert.Contains(t, topic.Content, "## Flags")
-	assert.Contains(t, topic.Content, "--help")
+	AssertContains(t, topic.Content, "## Usage")
+	AssertContains(t, topic.Content, "## Flags")
+	AssertContains(t, topic.Content, "--help")
 }
 
-func TestParseHelpText_Good_CommandsWithSingleWordEntry(t *testing.T) {
+func TestParseHelpText_Good_CommandsWithSingleWordEntry(t *T) {
 	// Subcommand listing with a single-word entry (no description)
 	helpText := `Available Commands:
   help
 
 `
 	topic := ParseHelpText("test", helpText)
-	assert.Contains(t, topic.Content, "## Commands")
-	assert.Contains(t, topic.Content, "help")
+	AssertContains(t, topic.Content, "## Commands")
+	AssertContains(t, topic.Content, "help")
 }
 
-func TestEndsCodeBlockSection_Good(t *testing.T) {
-	assert.True(t, endsCodeBlockSection("Usage:"))
-	assert.True(t, endsCodeBlockSection("Flags:"))
-	assert.True(t, endsCodeBlockSection("Options:"))
-	assert.True(t, endsCodeBlockSection("Examples:"))
-	assert.True(t, endsCodeBlockSection("Commands:"))
-	assert.True(t, endsCodeBlockSection("Available Commands:"))
-	assert.True(t, endsCodeBlockSection("See also: something"))
-	assert.False(t, endsCodeBlockSection("  -h, --help"))
-	assert.False(t, endsCodeBlockSection("some random text"))
+func TestEndsCodeBlockSection_Good(t *T) {
+	AssertTrue(t, endsCodeBlockSection("Usage:"))
+	AssertTrue(t, endsCodeBlockSection("Flags:"))
+	AssertTrue(t, endsCodeBlockSection("Options:"))
+	AssertTrue(t, endsCodeBlockSection("Examples:"))
+	AssertTrue(t, endsCodeBlockSection("Commands:"))
+	AssertTrue(t, endsCodeBlockSection("Available Commands:"))
+	AssertTrue(t, endsCodeBlockSection("See also: something"))
+	AssertFalse(t, endsCodeBlockSection("  -h, --help"))
+	AssertFalse(t, endsCodeBlockSection("some random text"))
 }
 
-func TestIsSectionHeader_Good(t *testing.T) {
-	assert.True(t, isSectionHeader("Usage:", "Usage:"))
-	assert.True(t, isSectionHeader("usage:", "Usage:"))
-	assert.False(t, isSectionHeader("NotUsage:", "Usage:"))
+func TestIsSectionHeader_Good(t *T) {
+	AssertTrue(t, isSectionHeader("Usage:", "Usage:"))
+	AssertTrue(t, isSectionHeader("usage:", "Usage:"))
+	AssertFalse(t, isSectionHeader("NotUsage:", "Usage:"))
 }
diff --git a/pkg/help/integration_test.go b/pkg/help/integration_test.go
index 47109b9..34bc025 100644
--- a/pkg/help/integration_test.go
+++ b/pkg/help/integration_test.go
@@ -2,22 +2,19 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"encoding/json"
 	"os"
 	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestIntegration_Good_FullPipeline(t *testing.T) {
+func TestIntegration_Good_FullPipeline(t *T) {
 	// 1. Create content directory
 	contentDir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(contentDir, "cli"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(contentDir, "go"), 0o755))
+	RequireNoError(t, os.MkdirAll(filepath.Join(contentDir, "cli"), 0o755))
+	RequireNoError(t, os.MkdirAll(filepath.Join(contentDir, "go"), 0o755))
 
-	require.NoError(t, os.WriteFile(filepath.Join(contentDir, "cli", "dev-work.md"), []byte(`---
+	RequireNoError(t, os.WriteFile(filepath.Join(contentDir, "cli", "dev-work.md"), []byte(`---
 title: Dev Work
 tags: [cli]
 order: 1
@@ -32,7 +29,7 @@ core dev work syncs your workspace.
 --status  Show status only
 `), 0o644))
 
-	require.NoError(t, os.WriteFile(filepath.Join(contentDir, "go", "go-scm.md"), []byte(`---
+	RequireNoError(t, os.WriteFile(filepath.Join(contentDir, "go", "go-scm.md"), []byte(`---
 title: Go SCM
 tags: [go, library]
 order: 2
@@ -45,46 +42,52 @@ Registry and git operations for the workspace.
 
 	// 2. Load into catalog
 	catalog, err := LoadContentDir(contentDir)
-	require.NoError(t, err)
-	assert.Len(t, catalog.List(), 2)
+	RequireNoError(t, err)
+	AssertLen(t, catalog.List(), 2)
 
 	// 3. Generate static site
 	outputDir := t.TempDir()
 	err = Generate(catalog, outputDir)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 
 	// 4. Verify file structure
-	assert.FileExists(t, filepath.Join(outputDir, "index.html"))
-	assert.FileExists(t, filepath.Join(outputDir, "search.html"))
-	assert.FileExists(t, filepath.Join(outputDir, "search-index.json"))
-	assert.FileExists(t, filepath.Join(outputDir, "404.html"))
-	assert.FileExists(t, filepath.Join(outputDir, "topics", "dev-work.html"))
-	assert.FileExists(t, filepath.Join(outputDir, "topics", "go-scm.html"))
+	_, err = os.Stat(filepath.Join(outputDir, "index.html"))
+	AssertNoError(t, err)
+	_, err = os.Stat(filepath.Join(outputDir, "search.html"))
+	AssertNoError(t, err)
+	_, err = os.Stat(filepath.Join(outputDir, "search-index.json"))
+	AssertNoError(t, err)
+	_, err = os.Stat(filepath.Join(outputDir, "404.html"))
+	AssertNoError(t, err)
+	_, err = os.Stat(filepath.Join(outputDir, "topics", "dev-work.html"))
+	AssertNoError(t, err)
+	_, err = os.Stat(filepath.Join(outputDir, "topics", "go-scm.html"))
+	AssertNoError(t, err)
 
 	// 5. Verify search index
 	indexData, err := os.ReadFile(filepath.Join(outputDir, "search-index.json"))
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	var entries []searchIndexEntry
-	require.NoError(t, json.Unmarshal(indexData, &entries))
-	assert.Len(t, entries, 2)
+	RequireNoError(t, json.Unmarshal(indexData, &entries))
+	AssertLen(t, entries, 2)
 
 	// 6. Verify HTML content has HLCRF structure
 	indexHTML, err := os.ReadFile(filepath.Join(outputDir, "index.html"))
-	require.NoError(t, err)
-	assert.Contains(t, string(indexHTML), "Dev Work")
-	assert.Contains(t, string(indexHTML), "Go SCM")
-	assert.Contains(t, string(indexHTML), `role="banner"`)
-	assert.Contains(t, string(indexHTML), `role="main"`)
+	RequireNoError(t, err)
+	AssertContains(t, string(indexHTML), "Dev Work")
+	AssertContains(t, string(indexHTML), "Go SCM")
+	AssertContains(t, string(indexHTML), `role="banner"`)
+	AssertContains(t, string(indexHTML), `role="main"`)
 
 	// 7. Verify topic page has section anchors
 	topicHTML, err := os.ReadFile(filepath.Join(outputDir, "topics", "dev-work.html"))
-	require.NoError(t, err)
-	assert.Contains(t, string(topicHTML), `href="#usage"`)
-	assert.Contains(t, string(topicHTML), `href="#flags"`)
-	assert.Contains(t, string(topicHTML), `role="complementary"`)
+	RequireNoError(t, err)
+	AssertContains(t, string(topicHTML), `href="#usage"`)
+	AssertContains(t, string(topicHTML), `href="#flags"`)
+	AssertContains(t, string(topicHTML), `role="complementary"`)
 
 	// 8. Search works
 	results := catalog.Search("workspace")
-	assert.NotEmpty(t, results)
-	assert.Equal(t, "dev-work", results[0].Topic.ID)
+	AssertNotEmpty(t, results)
+	AssertEqual(t, "dev-work", results[0].Topic.ID)
 }
diff --git a/pkg/help/layout.go b/pkg/help/layout.go
index 4be033f..f2f9608 100644
--- a/pkg/help/layout.go
+++ b/pkg/help/layout.go
@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"html"
 	"strings"
-
-	gohtml "forge.lthn.ai/core/go-html"
 )
 
 // pageCSS is the shared dark-theme stylesheet embedded in every page.
@@ -155,29 +153,37 @@ li { margin: 0.25rem 0; }
 .centre { text-align: center; }
 `
 
-// wrapPage wraps an HLCRF layout node in a complete HTML document.
-func wrapPage(title string, layout gohtml.Node) string {
-	head := gohtml.Raw(fmt.Sprintf(
+// wrapPage wraps semantic page regions in a complete HTML document.
+func wrapPage(title string, body string) string {
+	return fmt.Sprintf(
 		`<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8">`+
 			`<meta name="viewport" content="width=device-width, initial-scale=1.0">`+
 			`<title>%s</title><style>%s</style></head><body>`,
 		html.EscapeString(title), pageCSS,
-	))
-	tail := gohtml.Raw(`</body></html>`)
-
-	doc := gohtml.El("div", head, layout, tail)
-	ctx := gohtml.NewContext()
-	// Render and strip the wrapper div
-	rendered := gohtml.Render(doc, ctx)
-	rendered = strings.TrimPrefix(rendered, "<div>")
-	rendered = strings.TrimSuffix(rendered, "</div>")
-	return rendered
+	) + body + `</body></html>`
+}
+
+func renderHCF(title, header, content, footer string) string {
+	return wrapPage(title,
+		`<header role="banner" data-block="H">`+header+`</header>`+
+			`<main role="main" data-block="C">`+content+`</main>`+
+			`<footer role="contentinfo" data-block="F">`+footer+`</footer>`,
+	)
+}
+
+func renderHLCF(title, header, sidebar, content, footer string) string {
+	return wrapPage(title,
+		`<header role="banner" data-block="H">`+header+`</header>`+
+			`<aside role="complementary" data-block="L">`+sidebar+`</aside>`+
+			`<main role="main" data-block="C">`+content+`</main>`+
+			`<footer role="contentinfo" data-block="F">`+footer+`</footer>`,
+	)
 }
 
 // headerNav returns the HLCRF Header node: nav bar with brand + search form.
-func headerNav(searchValue string) gohtml.Node {
+func headerNav(searchValue string) string {
 	escapedValue := html.EscapeString(searchValue)
-	return gohtml.Raw(fmt.Sprintf(
+	return fmt.Sprintf(
 		`<nav><div class="container">`+
 			`<a href="/" class="brand">core.help</a>`+
 			`<form class="search-form" action="/search" method="get">`+
@@ -185,22 +191,20 @@ func headerNav(searchValue string) gohtml.Node {
 			`</form>`+
 			`</div></nav>`,
 		escapedValue,
-	))
+	)
 }
 
 // footerContent returns the HLCRF Footer node: licence + source link.
-func footerContent() gohtml.Node {
-	return gohtml.Raw(
-		`<div class="container">` +
-			`EUPL-1.2 &middot; <a href="https://forge.lthn.ai/core/docs">forge.lthn.ai/core/docs</a>` +
-			`</div>`,
-	)
+func footerContent() string {
+	return `<div class="container">` +
+		`EUPL-1.2 &middot; <a href="https://forge.lthn.ai/core/docs">forge.lthn.ai/core/docs</a>` +
+		`</div>`
 }
 
 // sidebarTopicTree returns a sidebar node showing topics grouped by tag.
-func sidebarTopicTree(topics []*Topic) gohtml.Node {
+func sidebarTopicTree(topics []*Topic) string {
 	if len(topics) == 0 {
-		return gohtml.Raw("")
+		return ""
 	}
 
 	groups := groupTopicsByTag(topics)
@@ -224,13 +228,13 @@ func sidebarTopicTree(topics []*Topic) gohtml.Node {
 	}
 
 	b.WriteString(`</div>`)
-	return gohtml.Raw(b.String())
+	return b.String()
 }
 
 // topicTableOfContents returns a ToC node with section anchors.
-func topicTableOfContents(sections []Section) gohtml.Node {
+func topicTableOfContents(sections []Section) string {
 	if len(sections) == 0 {
-		return gohtml.Raw("")
+		return ""
 	}
 
 	var b strings.Builder
@@ -245,7 +249,7 @@ func topicTableOfContents(sections []Section) gohtml.Node {
 		))
 	}
 	b.WriteString(`</ul></div>`)
-	return gohtml.Raw(b.String())
+	return b.String()
 }
 
 // truncateContent returns a plain-text preview of markdown content.
@@ -269,12 +273,6 @@ func truncateContent(content string, maxLen int) string {
 
 // RenderIndexPage renders a full HTML page listing topics grouped by tag.
 func RenderIndexPage(topics []*Topic) string {
-	layout := gohtml.NewLayout("HCF")
-
-	// Header
-	layout.H(headerNav(""))
-
-	// Content
 	var content strings.Builder
 	content.WriteString(`<div class="container">`)
 
@@ -326,32 +324,14 @@ func RenderIndexPage(topics []*Topic) string {
 	}
 
 	content.WriteString(`</div>`)
-	layout.C(gohtml.Raw(content.String()))
-
-	// Footer
-	layout.F(footerContent())
 
-	return wrapPage("Help Topics", layout)
+	return renderHCF("Help Topics", headerNav(""), content.String(), footerContent())
 }
 
 // RenderTopicPage renders a full HTML page for a single topic with ToC and sidebar.
 func RenderTopicPage(topic *Topic, sidebar []*Topic) string {
 	hasSidebar := len(sidebar) > 0
-	variant := "HCF"
-	if hasSidebar {
-		variant = "HLCF"
-	}
-	layout := gohtml.NewLayout(variant)
-
-	// Header
-	layout.H(headerNav(""))
 
-	// Left sidebar (only when sidebar topics provided)
-	if hasSidebar {
-		layout.L(sidebarTopicTree(sidebar))
-	}
-
-	// Content
 	var content strings.Builder
 	content.WriteString(`<div class="container">`)
 
@@ -369,8 +349,7 @@ func RenderTopicPage(topic *Topic, sidebar []*Topic) string {
 
 	// Table of contents (inline, before content)
 	if len(topic.Sections) > 0 {
-		ctx := gohtml.NewContext()
-		content.WriteString(topicTableOfContents(topic.Sections).Render(ctx))
+		content.WriteString(topicTableOfContents(topic.Sections))
 	}
 
 	// Rendered markdown body
@@ -398,23 +377,16 @@ func RenderTopicPage(topic *Topic, sidebar []*Topic) string {
 	}
 
 	content.WriteString(`</div>`)
-	layout.C(gohtml.Raw(content.String()))
-
-	// Footer
-	layout.F(footerContent())
 
 	title := html.EscapeString(topic.Title) + " - Help"
-	return wrapPage(title, layout)
+	if hasSidebar {
+		return renderHLCF(title, headerNav(""), sidebarTopicTree(sidebar), content.String(), footerContent())
+	}
+	return renderHCF(title, headerNav(""), content.String(), footerContent())
 }
 
 // RenderSearchPage renders a full HTML page showing search results.
 func RenderSearchPage(query string, results []*SearchResult) string {
-	layout := gohtml.NewLayout("HCF")
-
-	// Header (pre-fill search box with query)
-	layout.H(headerNav(query))
-
-	// Content
 	var content strings.Builder
 	content.WriteString(`<div class="container">`)
 	content.WriteString(`<h1>Search Results</h1>`)
@@ -464,34 +436,18 @@ func RenderSearchPage(query string, results []*SearchResult) string {
 	}
 
 	content.WriteString(`</div>`)
-	layout.C(gohtml.Raw(content.String()))
-
-	// Footer
-	layout.F(footerContent())
 
-	return wrapPage("Search: "+html.EscapeString(query)+" - Help", layout)
+	return renderHCF("Search: "+html.EscapeString(query)+" - Help", headerNav(query), content.String(), footerContent())
 }
 
 // Render404Page renders a full HTML "Not Found" page.
 func Render404Page() string {
-	layout := gohtml.NewLayout("HCF")
-
-	// Header
-	layout.H(headerNav(""))
-
-	// Content
-	content := gohtml.Raw(
-		`<div class="container centre" style="margin-top: 4rem;">` +
-			`<h1 style="font-size: 3rem; border: none; color: var(--fg-muted);">404</h1>` +
-			`<p style="font-size: 1.1rem; color: var(--fg-muted);">Not Found</p>` +
-			`<p style="margin-top: 1.5rem;">` +
-			`<a href="/">Browse all topics</a> or try searching above.` +
-			`</p></div>`,
-	)
-	layout.C(content)
-
-	// Footer
-	layout.F(footerContent())
-
-	return wrapPage("Not Found - Help", layout)
+	content := `<div class="container centre" style="margin-top: 4rem;">` +
+		`<h1 style="font-size: 3rem; border: none; color: var(--fg-muted);">404</h1>` +
+		`<p style="font-size: 1.1rem; color: var(--fg-muted);">Not Found</p>` +
+		`<p style="margin-top: 1.5rem;">` +
+		`<a href="/">Browse all topics</a> or try searching above.` +
+		`</p></div>`
+
+	return renderHCF("Not Found - Help", headerNav(""), content, footerContent())
 }
diff --git a/pkg/help/layout_test.go b/pkg/help/layout_test.go
index a26d08e..426f71f 100644
--- a/pkg/help/layout_test.go
+++ b/pkg/help/layout_test.go
@@ -2,14 +2,11 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestRenderLayout_Good_IndexPage(t *testing.T) {
+func TestRenderLayout_Good_IndexPage(t *T) {
 	topics := []*Topic{
 		{ID: "getting-started", Title: "Getting Started", Tags: []string{"intro"}, Content: "Welcome to the guide."},
 		{ID: "config", Title: "Configuration", Tags: []string{"setup"}, Content: "Config options here."},
@@ -19,24 +16,24 @@ func TestRenderLayout_Good_IndexPage(t *testing.T) {
 	html := RenderIndexPage(topics)
 
 	// Must contain ARIA roles from HLCRF layout
-	assert.Contains(t, html, `role="banner"`, "header should have banner role")
-	assert.Contains(t, html, `role="main"`, "content should have main role")
-	assert.Contains(t, html, `role="contentinfo"`, "footer should have contentinfo role")
+	AssertContains(t, html, `role="banner"`, "header should have banner role")
+	AssertContains(t, html, `role="main"`, "content should have main role")
+	AssertContains(t, html, `role="contentinfo"`, "footer should have contentinfo role")
 
 	// Must contain topic titles
-	assert.Contains(t, html, "Getting Started")
-	assert.Contains(t, html, "Configuration")
-	assert.Contains(t, html, "Advanced Usage")
+	AssertContains(t, html, "Getting Started")
+	AssertContains(t, html, "Configuration")
+	AssertContains(t, html, "Advanced Usage")
 
 	// Must contain brand
-	assert.Contains(t, html, "core.help")
+	AssertContains(t, html, "core.help")
 
 	// Must contain tag group headings
-	assert.Contains(t, html, "intro")
-	assert.Contains(t, html, "setup")
+	AssertContains(t, html, "intro")
+	AssertContains(t, html, "setup")
 }
 
-func TestRenderLayout_Good_TopicPage(t *testing.T) {
+func TestRenderLayout_Good_TopicPage(t *T) {
 	topic := &Topic{
 		ID:      "getting-started",
 		Title:   "Getting Started",
@@ -58,29 +55,29 @@ func TestRenderLayout_Good_TopicPage(t *testing.T) {
 	html := RenderTopicPage(topic, sidebar)
 
 	// Must have table of contents with section anchors
-	assert.Contains(t, html, `href="#overview"`, "ToC should link to overview section")
-	assert.Contains(t, html, `href="#installation"`, "ToC should link to installation section")
-	assert.Contains(t, html, `href="#quick-start"`, "ToC should link to quick-start section")
+	AssertContains(t, html, `href="#overview"`, "ToC should link to overview section")
+	AssertContains(t, html, `href="#installation"`, "ToC should link to installation section")
+	AssertContains(t, html, `href="#quick-start"`, "ToC should link to quick-start section")
 
 	// Must contain section titles in the ToC
-	assert.Contains(t, html, "Overview")
-	assert.Contains(t, html, "Installation")
-	assert.Contains(t, html, "Quick Start")
+	AssertContains(t, html, "Overview")
+	AssertContains(t, html, "Installation")
+	AssertContains(t, html, "Quick Start")
 
 	// Must contain rendered markdown content
-	assert.Contains(t, html, "<strong>guide</strong>")
+	AssertContains(t, html, "<strong>guide</strong>")
 
 	// Must have sidebar with topic links
-	assert.Contains(t, html, "Configuration")
+	AssertContains(t, html, "Configuration")
 
 	// Must have ARIA roles
-	assert.Contains(t, html, `role="banner"`)
-	assert.Contains(t, html, `role="main"`)
-	assert.Contains(t, html, `role="complementary"`)
-	assert.Contains(t, html, `role="contentinfo"`)
+	AssertContains(t, html, `role="banner"`)
+	AssertContains(t, html, `role="main"`)
+	AssertContains(t, html, `role="complementary"`)
+	AssertContains(t, html, `role="contentinfo"`)
 }
 
-func TestRenderLayout_Good_TopicPage_NoSidebar(t *testing.T) {
+func TestRenderLayout_Good_TopicPage_NoSidebar(t *T) {
 	topic := &Topic{
 		ID:      "solo",
 		Title:   "Solo Topic",
@@ -90,14 +87,14 @@ func TestRenderLayout_Good_TopicPage_NoSidebar(t *testing.T) {
 	html := RenderTopicPage(topic, nil)
 
 	// Should still render content
-	assert.Contains(t, html, "Solo Topic")
-	assert.Contains(t, html, `role="main"`)
+	AssertContains(t, html, "Solo Topic")
+	AssertContains(t, html, `role="main"`)
 
 	// Without sidebar topics, left aside should not appear
-	assert.NotContains(t, html, `role="complementary"`)
+	AssertNotContains(t, html, `role="complementary"`)
 }
 
-func TestRenderLayout_Good_SearchPage(t *testing.T) {
+func TestRenderLayout_Good_SearchPage(t *T) {
 	results := []*SearchResult{
 		{
 			Topic:   &Topic{ID: "install", Title: "Installation Guide", Tags: []string{"setup"}},
@@ -114,25 +111,25 @@ func TestRenderLayout_Good_SearchPage(t *testing.T) {
 	html := RenderSearchPage("install", results)
 
 	// Must show the query
-	assert.Contains(t, html, "install")
+	AssertContains(t, html, "install")
 
 	// Must show result titles
-	assert.Contains(t, html, "Installation Guide")
-	assert.Contains(t, html, "Configuration")
+	AssertContains(t, html, "Installation Guide")
+	AssertContains(t, html, "Configuration")
 
 	// Must have ARIA roles
-	assert.Contains(t, html, `role="banner"`)
-	assert.Contains(t, html, `role="main"`)
+	AssertContains(t, html, `role="banner"`)
+	AssertContains(t, html, `role="main"`)
 }
 
-func TestRenderLayout_Good_SearchPage_NoResults(t *testing.T) {
+func TestRenderLayout_Good_SearchPage_NoResults(t *T) {
 	html := RenderSearchPage("nonexistent", nil)
 
-	assert.Contains(t, html, "nonexistent")
-	assert.Contains(t, html, "No results")
+	AssertContains(t, html, "nonexistent")
+	AssertContains(t, html, "No results")
 }
 
-func TestRenderLayout_Good_HasDoctype(t *testing.T) {
+func TestRenderLayout_Good_HasDoctype(t *T) {
 	tests := []struct {
 		name string
 		html string
@@ -144,33 +141,33 @@ func TestRenderLayout_Good_HasDoctype(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			require.True(t, strings.HasPrefix(tt.html, "<!DOCTYPE html>"),
+		t.Run(tt.name, func(t *T) {
+			RequireTrue(t, strings.HasPrefix(tt.html, "<!DOCTYPE html>"),
 				"page should start with <!DOCTYPE html>, got: %s", tt.html[:min(50, len(tt.html))])
 		})
 	}
 }
 
-func TestRenderLayout_Good_404Page(t *testing.T) {
+func TestRenderLayout_Good_404Page(t *T) {
 	html := Render404Page()
 
-	assert.Contains(t, html, "Not Found")
-	assert.Contains(t, html, "404")
-	assert.Contains(t, html, `role="banner"`)
-	assert.Contains(t, html, `role="main"`)
-	assert.Contains(t, html, `role="contentinfo"`)
+	AssertContains(t, html, "Not Found")
+	AssertContains(t, html, "404")
+	AssertContains(t, html, `role="banner"`)
+	AssertContains(t, html, `role="main"`)
+	AssertContains(t, html, `role="contentinfo"`)
 }
 
-func TestRenderLayout_Good_EscapesHTML(t *testing.T) {
+func TestRenderLayout_Good_EscapesHTML(t *T) {
 	topic := &Topic{
-		ID:    "xss",
-		Title: `<script>alert("xss")</script>`,
+		ID:      "xss",
+		Title:   `<script>alert("xss")</script>`,
 		Content: "Safe content.",
 	}
 
 	html := RenderIndexPage([]*Topic{topic})
 
 	// Title must be escaped
-	assert.NotContains(t, html, `<script>alert`)
-	assert.Contains(t, html, "&lt;script&gt;")
+	AssertNotContains(t, html, `<script>alert`)
+	AssertContains(t, html, "&lt;script&gt;")
 }
diff --git a/pkg/help/parser_test.go b/pkg/help/parser_test.go
index 9f7a9c8..b1c87c4 100644
--- a/pkg/help/parser_test.go
+++ b/pkg/help/parser_test.go
@@ -2,15 +2,12 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"fmt"
 	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestGenerateID_Good(t *testing.T) {
+func TestGenerateID_Good(t *T) {
 	tests := []struct {
 		name     string
 		input    string
@@ -64,14 +61,14 @@ func TestGenerateID_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			result := GenerateID(tt.input)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
-func TestExtractFrontmatter_Good(t *testing.T) {
+func TestExtractFrontmatter_Good(t *T) {
 	content := `---
 title: Getting Started
 tags: [intro, setup]
@@ -88,16 +85,16 @@ This is the content.
 
 	fm, body := ExtractFrontmatter(content)
 
-	assert.NotNil(t, fm)
-	assert.Equal(t, "Getting Started", fm.Title)
-	assert.Equal(t, []string{"intro", "setup"}, fm.Tags)
-	assert.Equal(t, 1, fm.Order)
-	assert.Equal(t, []string{"installation", "configuration"}, fm.Related)
-	assert.Contains(t, body, "# Welcome")
-	assert.Contains(t, body, "This is the content.")
+	AssertNotNil(t, fm)
+	AssertEqual(t, "Getting Started", fm.Title)
+	AssertEqual(t, []string{"intro", "setup"}, fm.Tags)
+	AssertEqual(t, 1, fm.Order)
+	AssertEqual(t, []string{"installation", "configuration"}, fm.Related)
+	AssertContains(t, body, "# Welcome")
+	AssertContains(t, body, "This is the content.")
 }
 
-func TestExtractFrontmatter_Good_NoFrontmatter(t *testing.T) {
+func TestExtractFrontmatter_Good_NoFrontmatter(t *T) {
 	content := `# Just a Heading
 
 Some content here.
@@ -105,34 +102,34 @@ Some content here.
 
 	fm, body := ExtractFrontmatter(content)
 
-	assert.Nil(t, fm)
-	assert.Equal(t, content, body)
+	AssertNil(t, fm)
+	AssertEqual(t, content, body)
 }
 
-func TestExtractFrontmatter_Good_CRLF(t *testing.T) {
+func TestExtractFrontmatter_Good_CRLF(t *T) {
 	// Content with CRLF line endings (Windows-style)
 	content := "---\r\ntitle: CRLF Test\r\n---\r\n\r\n# Content"
 
 	fm, body := ExtractFrontmatter(content)
 
-	assert.NotNil(t, fm)
-	assert.Equal(t, "CRLF Test", fm.Title)
-	assert.Contains(t, body, "# Content")
+	AssertNotNil(t, fm)
+	AssertEqual(t, "CRLF Test", fm.Title)
+	AssertContains(t, body, "# Content")
 }
 
-func TestExtractFrontmatter_Good_Empty(t *testing.T) {
+func TestExtractFrontmatter_Good_Empty(t *T) {
 	// Empty frontmatter block
 	content := "---\n---\n# Content"
 
 	fm, body := ExtractFrontmatter(content)
 
 	// Empty frontmatter should parse successfully
-	assert.NotNil(t, fm)
-	assert.Equal(t, "", fm.Title)
-	assert.Contains(t, body, "# Content")
+	AssertNotNil(t, fm)
+	AssertEqual(t, "", fm.Title)
+	AssertContains(t, body, "# Content")
 }
 
-func TestExtractFrontmatter_Bad_InvalidYAML(t *testing.T) {
+func TestExtractFrontmatter_Bad_InvalidYAML(t *T) {
 	content := `---
 title: [invalid yaml
 ---
@@ -143,11 +140,11 @@ title: [invalid yaml
 	fm, body := ExtractFrontmatter(content)
 
 	// Invalid YAML should return nil frontmatter and original content
-	assert.Nil(t, fm)
-	assert.Equal(t, content, body)
+	AssertNil(t, fm)
+	AssertEqual(t, content, body)
 }
 
-func TestExtractSections_Good(t *testing.T) {
+func TestExtractSections_Good(t *T) {
 	content := `# Main Title
 
 Introduction paragraph.
@@ -168,35 +165,35 @@ Config info here.
 
 	sections := ExtractSections(content)
 
-	assert.Len(t, sections, 4)
+	AssertLen(t, sections, 4)
 
 	// Main Title (H1)
-	assert.Equal(t, "main-title", sections[0].ID)
-	assert.Equal(t, "Main Title", sections[0].Title)
-	assert.Equal(t, 1, sections[0].Level)
-	assert.Equal(t, 1, sections[0].Line)
-	assert.Contains(t, sections[0].Content, "Introduction paragraph.")
+	AssertEqual(t, "main-title", sections[0].ID)
+	AssertEqual(t, "Main Title", sections[0].Title)
+	AssertEqual(t, 1, sections[0].Level)
+	AssertEqual(t, 1, sections[0].Line)
+	AssertContains(t, sections[0].Content, "Introduction paragraph.")
 
 	// Installation (H2)
-	assert.Equal(t, "installation", sections[1].ID)
-	assert.Equal(t, "Installation", sections[1].Title)
-	assert.Equal(t, 2, sections[1].Level)
-	assert.Contains(t, sections[1].Content, "Install instructions here.")
-	assert.Contains(t, sections[1].Content, "More details.")
+	AssertEqual(t, "installation", sections[1].ID)
+	AssertEqual(t, "Installation", sections[1].Title)
+	AssertEqual(t, 2, sections[1].Level)
+	AssertContains(t, sections[1].Content, "Install instructions here.")
+	AssertContains(t, sections[1].Content, "More details.")
 
 	// Prerequisites (H3)
-	assert.Equal(t, "prerequisites", sections[2].ID)
-	assert.Equal(t, "Prerequisites", sections[2].Title)
-	assert.Equal(t, 3, sections[2].Level)
-	assert.Contains(t, sections[2].Content, "You need these things.")
+	AssertEqual(t, "prerequisites", sections[2].ID)
+	AssertEqual(t, "Prerequisites", sections[2].Title)
+	AssertEqual(t, 3, sections[2].Level)
+	AssertContains(t, sections[2].Content, "You need these things.")
 
 	// Configuration (H2)
-	assert.Equal(t, "configuration", sections[3].ID)
-	assert.Equal(t, "Configuration", sections[3].Title)
-	assert.Equal(t, 2, sections[3].Level)
+	AssertEqual(t, "configuration", sections[3].ID)
+	AssertEqual(t, "Configuration", sections[3].Title)
+	AssertEqual(t, 2, sections[3].Level)
 }
 
-func TestExtractSections_Good_AllHeadingLevels(t *testing.T) {
+func TestExtractSections_Good_AllHeadingLevels(t *T) {
 	content := `# H1
 ## H2
 ### H3
@@ -207,23 +204,23 @@ func TestExtractSections_Good_AllHeadingLevels(t *testing.T) {
 
 	sections := ExtractSections(content)
 
-	assert.Len(t, sections, 6)
+	AssertLen(t, sections, 6)
 	for i, level := range []int{1, 2, 3, 4, 5, 6} {
-		assert.Equal(t, level, sections[i].Level)
+		AssertEqual(t, level, sections[i].Level)
 	}
 }
 
-func TestExtractSections_Good_Empty(t *testing.T) {
+func TestExtractSections_Good_Empty(t *T) {
 	content := `Just plain text.
 No headings here.
 `
 
 	sections := ExtractSections(content)
 
-	assert.Empty(t, sections)
+	AssertEmpty(t, sections)
 }
 
-func TestParseTopic_Good(t *testing.T) {
+func TestParseTopic_Good(t *T) {
 	content := []byte(`---
 title: Quick Start Guide
 tags: [intro, quickstart]
@@ -247,29 +244,29 @@ Then do this.
 
 	topic, err := ParseTopic("docs/quick-start.md", content)
 
-	assert.NoError(t, err)
-	assert.NotNil(t, topic)
+	AssertNoError(t, err)
+	AssertNotNil(t, topic)
 
 	// Check metadata from frontmatter
-	assert.Equal(t, "quick-start-guide", topic.ID)
-	assert.Equal(t, "Quick Start Guide", topic.Title)
-	assert.Equal(t, "docs/quick-start.md", topic.Path)
-	assert.Equal(t, []string{"intro", "quickstart"}, topic.Tags)
-	assert.Equal(t, []string{"installation"}, topic.Related)
-	assert.Equal(t, 5, topic.Order)
+	AssertEqual(t, "quick-start-guide", topic.ID)
+	AssertEqual(t, "Quick Start Guide", topic.Title)
+	AssertEqual(t, "docs/quick-start.md", topic.Path)
+	AssertEqual(t, []string{"intro", "quickstart"}, topic.Tags)
+	AssertEqual(t, []string{"installation"}, topic.Related)
+	AssertEqual(t, 5, topic.Order)
 
 	// Check sections
-	assert.Len(t, topic.Sections, 3)
-	assert.Equal(t, "quick-start-guide", topic.Sections[0].ID)
-	assert.Equal(t, "first-steps", topic.Sections[1].ID)
-	assert.Equal(t, "next-steps", topic.Sections[2].ID)
+	AssertLen(t, topic.Sections, 3)
+	AssertEqual(t, "quick-start-guide", topic.Sections[0].ID)
+	AssertEqual(t, "first-steps", topic.Sections[1].ID)
+	AssertEqual(t, "next-steps", topic.Sections[2].ID)
 
 	// Content should not include frontmatter
-	assert.NotContains(t, topic.Content, "---")
-	assert.Contains(t, topic.Content, "# Quick Start Guide")
+	AssertNotContains(t, topic.Content, "---")
+	AssertContains(t, topic.Content, "# Quick Start Guide")
 }
 
-func TestParseTopic_Good_NoFrontmatter(t *testing.T) {
+func TestParseTopic_Good_NoFrontmatter(t *T) {
 	content := []byte(`# Getting Started
 
 This is a simple doc.
@@ -281,18 +278,18 @@ Install it here.
 
 	topic, err := ParseTopic("getting-started.md", content)
 
-	assert.NoError(t, err)
-	assert.NotNil(t, topic)
+	AssertNoError(t, err)
+	AssertNotNil(t, topic)
 
 	// Title should come from first H1
-	assert.Equal(t, "Getting Started", topic.Title)
-	assert.Equal(t, "getting-started", topic.ID)
+	AssertEqual(t, "Getting Started", topic.Title)
+	AssertEqual(t, "getting-started", topic.ID)
 
 	// Sections extracted
-	assert.Len(t, topic.Sections, 2)
+	AssertLen(t, topic.Sections, 2)
 }
 
-func TestParseTopic_Good_NoHeadings(t *testing.T) {
+func TestParseTopic_Good_NoHeadings(t *T) {
 	content := []byte(`---
 title: Plain Content
 ---
@@ -302,27 +299,27 @@ Just some text without any headings.
 
 	topic, err := ParseTopic("plain.md", content)
 
-	assert.NoError(t, err)
-	assert.NotNil(t, topic)
-	assert.Equal(t, "Plain Content", topic.Title)
-	assert.Equal(t, "plain-content", topic.ID)
-	assert.Empty(t, topic.Sections)
+	AssertNoError(t, err)
+	AssertNotNil(t, topic)
+	AssertEqual(t, "Plain Content", topic.Title)
+	AssertEqual(t, "plain-content", topic.ID)
+	AssertEmpty(t, topic.Sections)
 }
 
-func TestParseTopic_Good_IDFromPath(t *testing.T) {
+func TestParseTopic_Good_IDFromPath(t *T) {
 	content := []byte(`Just content, no frontmatter or headings.`)
 
 	topic, err := ParseTopic("commands/dev-workflow.md", content)
 
-	assert.NoError(t, err)
-	assert.NotNil(t, topic)
+	AssertNoError(t, err)
+	AssertNotNil(t, topic)
 
 	// ID and title should be derived from path
-	assert.Equal(t, "dev-workflow", topic.ID)
-	assert.Equal(t, "", topic.Title) // No title available
+	AssertEqual(t, "dev-workflow", topic.ID)
+	AssertEqual(t, "", topic.Title) // No title available
 }
 
-func TestPathToTitle_Good(t *testing.T) {
+func TestPathToTitle_Good(t *T) {
 	tests := []struct {
 		path     string
 		expected string
@@ -335,30 +332,30 @@ func TestPathToTitle_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.path, func(t *testing.T) {
+		t.Run(tt.path, func(t *T) {
 			result := pathToTitle(tt.path)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
 // --- Phase 0: Expanded parser tests ---
 
-func TestParseTopic_Good_EmptyInput(t *testing.T) {
+func TestParseTopic_Good_EmptyInput(t *T) {
 	// Empty byte slice should produce a valid topic with no content
 	topic, err := ParseTopic("empty.md", []byte(""))
 
-	require.NoError(t, err)
-	assert.NotNil(t, topic)
-	assert.Equal(t, "empty", topic.ID)
-	assert.Equal(t, "", topic.Title)
-	assert.Equal(t, "", topic.Content)
-	assert.Empty(t, topic.Sections)
-	assert.Empty(t, topic.Tags)
-	assert.Empty(t, topic.Related)
+	RequireNoError(t, err)
+	AssertNotNil(t, topic)
+	AssertEqual(t, "empty", topic.ID)
+	AssertEqual(t, "", topic.Title)
+	AssertEqual(t, "", topic.Content)
+	AssertEmpty(t, topic.Sections)
+	AssertEmpty(t, topic.Tags)
+	AssertEmpty(t, topic.Related)
 }
 
-func TestParseTopic_Good_FrontmatterOnly(t *testing.T) {
+func TestParseTopic_Good_FrontmatterOnly(t *T) {
 	// Frontmatter with no body or sections
 	content := []byte(`---
 title: Metadata Only
@@ -369,17 +366,17 @@ order: 99
 
 	topic, err := ParseTopic("meta.md", content)
 
-	require.NoError(t, err)
-	assert.Equal(t, "metadata-only", topic.ID)
-	assert.Equal(t, "Metadata Only", topic.Title)
-	assert.Equal(t, []string{"meta"}, topic.Tags)
-	assert.Equal(t, 99, topic.Order)
-	assert.Empty(t, topic.Sections)
+	RequireNoError(t, err)
+	AssertEqual(t, "metadata-only", topic.ID)
+	AssertEqual(t, "Metadata Only", topic.Title)
+	AssertEqual(t, []string{"meta"}, topic.Tags)
+	AssertEqual(t, 99, topic.Order)
+	AssertEmpty(t, topic.Sections)
 	// Body after frontmatter is just a newline
-	assert.Equal(t, "", strings.TrimSpace(topic.Content))
+	AssertEqual(t, "", strings.TrimSpace(topic.Content))
 }
 
-func TestExtractFrontmatter_Bad_MalformedYAML(t *testing.T) {
+func TestExtractFrontmatter_Bad_MalformedYAML(t *T) {
 	tests := []struct {
 		name    string
 		content string
@@ -412,19 +409,19 @@ title:
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			fm, body := ExtractFrontmatter(tt.content)
 			// Malformed YAML should return nil frontmatter without panic
 			if fm == nil {
 				// Body should be original content when YAML fails
-				assert.Equal(t, tt.content, body)
+				AssertEqual(t, tt.content, body)
 			}
 			// No panic is the key assertion — test reaching here is success
 		})
 	}
 }
 
-func TestExtractFrontmatter_Bad_NotAtStart(t *testing.T) {
+func TestExtractFrontmatter_Bad_NotAtStart(t *T) {
 	// Frontmatter delimiters that do not start at the beginning of the file
 	content := `Some preamble text.
 
@@ -436,11 +433,11 @@ title: Should Not Parse
 
 	fm, body := ExtractFrontmatter(content)
 
-	assert.Nil(t, fm)
-	assert.Equal(t, content, body)
+	AssertNil(t, fm)
+	AssertEqual(t, content, body)
 }
 
-func TestExtractSections_Good_DeeplyNested(t *testing.T) {
+func TestExtractSections_Good_DeeplyNested(t *T) {
 	content := `# Level 1
 
 Top-level content.
@@ -468,7 +465,7 @@ Deepest heading level.
 
 	sections := ExtractSections(content)
 
-	require.Len(t, sections, 6)
+	AssertLen(t, sections, 6)
 
 	for i, expected := range []struct {
 		level int
@@ -481,17 +478,17 @@ Deepest heading level.
 		{5, "Level 5"},
 		{6, "Level 6"},
 	} {
-		assert.Equal(t, expected.level, sections[i].Level, "section %d level", i)
-		assert.Equal(t, expected.title, sections[i].Title, "section %d title", i)
+		AssertEqual(t, expected.level, sections[i].Level, fmt.Sprintf("section %d level", i))
+		AssertEqual(t, expected.title, sections[i].Title, fmt.Sprintf("section %d title", i))
 	}
 
 	// Verify content is associated with correct sections
-	assert.Contains(t, sections[0].Content, "Top-level content.")
-	assert.Contains(t, sections[3].Content, "Fourth level details.")
-	assert.Contains(t, sections[5].Content, "Deepest heading level.")
+	AssertContains(t, sections[0].Content, "Top-level content.")
+	AssertContains(t, sections[3].Content, "Fourth level details.")
+	AssertContains(t, sections[5].Content, "Deepest heading level.")
 }
 
-func TestExtractSections_Good_DeeplyNestedWithContent(t *testing.T) {
+func TestExtractSections_Good_DeeplyNestedWithContent(t *T) {
 	// H4, H5, H6 with meaningful content under each
 	content := `#### Configuration Options
 
@@ -508,21 +505,21 @@ These may change without notice.
 
 	sections := ExtractSections(content)
 
-	require.Len(t, sections, 3)
-	assert.Equal(t, 4, sections[0].Level)
-	assert.Equal(t, "Configuration Options", sections[0].Title)
-	assert.Contains(t, sections[0].Content, "Set these in your config file.")
+	AssertLen(t, sections, 3)
+	AssertEqual(t, 4, sections[0].Level)
+	AssertEqual(t, "Configuration Options", sections[0].Title)
+	AssertContains(t, sections[0].Content, "Set these in your config file.")
 
-	assert.Equal(t, 5, sections[1].Level)
-	assert.Equal(t, "Advanced Options", sections[1].Title)
-	assert.Contains(t, sections[1].Content, "Only for power users.")
+	AssertEqual(t, 5, sections[1].Level)
+	AssertEqual(t, "Advanced Options", sections[1].Title)
+	AssertContains(t, sections[1].Content, "Only for power users.")
 
-	assert.Equal(t, 6, sections[2].Level)
-	assert.Equal(t, "Experimental Flags", sections[2].Title)
-	assert.Contains(t, sections[2].Content, "These may change without notice.")
+	AssertEqual(t, 6, sections[2].Level)
+	AssertEqual(t, "Experimental Flags", sections[2].Title)
+	AssertContains(t, sections[2].Content, "These may change without notice.")
 }
 
-func TestParseTopic_Good_Unicode(t *testing.T) {
+func TestParseTopic_Good_Unicode(t *T) {
 	tests := []struct {
 		name    string
 		content string
@@ -595,18 +592,18 @@ Content with Кириллица, 中文, العربية, and हिन्दी.
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			topic, err := ParseTopic("unicode.md", []byte(tt.content))
 
-			require.NoError(t, err)
-			assert.Equal(t, tt.title, topic.Title)
-			assert.NotEmpty(t, topic.ID)
-			assert.True(t, len(topic.Sections) > 0, "should extract sections from unicode content")
+			RequireNoError(t, err)
+			AssertEqual(t, tt.title, topic.Title)
+			AssertNotEmpty(t, topic.ID)
+			AssertTrue(t, len(topic.Sections) > 0, "should extract sections from unicode content")
 		})
 	}
 }
 
-func TestParseTopic_Good_VeryLongDocument(t *testing.T) {
+func TestParseTopic_Good_VeryLongDocument(t *T) {
 	// Build a document with 10,000+ lines
 	var b strings.Builder
 
@@ -623,30 +620,32 @@ func TestParseTopic_Good_VeryLongDocument(t *testing.T) {
 
 	content := b.String()
 	lineCount := strings.Count(content, "\n")
-	assert.Greater(t, lineCount, 10000, "document should exceed 10K lines")
+	AssertGreater(t, lineCount, 10000, "document should exceed 10K lines")
 
 	topic, err := ParseTopic("massive.md", []byte(content))
 
-	require.NoError(t, err)
-	assert.Equal(t, "Massive Document", topic.Title)
-	assert.Equal(t, "massive-document", topic.ID)
-	assert.Len(t, topic.Sections, 100)
+	RequireNoError(t, err)
+	AssertEqual(t, "Massive Document", topic.Title)
+	AssertEqual(t, "massive-document", topic.ID)
+	AssertLen(t, topic.Sections, 100)
 
 	// Verify first and last sections have correct titles
-	assert.Equal(t, "Section 1", topic.Sections[0].Title)
-	assert.Equal(t, "Section 100", topic.Sections[99].Title)
+	AssertEqual(t, "Section 1", topic.Sections[0].Title)
+	AssertEqual(t, "Section 100", topic.Sections[99].Title)
 
 	// Verify content is captured in sections
-	assert.Contains(t, topic.Sections[0].Content, "Line 1 of section 1")
-	assert.Contains(t, topic.Sections[99].Content, "Line 100 of section 100")
+	AssertContains(t, topic.Sections[0].Content, "Line 1 of section 1")
+	AssertContains(t, topic.Sections[99].Content, "Line 100 of section 100")
 }
 
-func TestExtractSections_Bad_EmptyString(t *testing.T) {
+func TestExtractSections_Bad_EmptyString(t *T) {
 	sections := ExtractSections("")
-	assert.Empty(t, sections)
+	AssertEmpty(t, sections)
+	AssertLen(t, sections, 0)
+	AssertFalse(t, len(sections) > 0)
 }
 
-func TestExtractSections_Bad_HeadingWithoutSpace(t *testing.T) {
+func TestExtractSections_Bad_HeadingWithoutSpace(t *T) {
 	// "#NoSpace" is not a valid markdown heading (needs space after #)
 	content := `#NoSpace
 ##AlsoNoSpace
@@ -654,10 +653,10 @@ Some text.
 `
 
 	sections := ExtractSections(content)
-	assert.Empty(t, sections, "headings without space after # should not be parsed")
+	AssertEmpty(t, sections, "headings without space after # should not be parsed")
 }
 
-func TestExtractSections_Good_ConsecutiveHeadings(t *testing.T) {
+func TestExtractSections_Good_ConsecutiveHeadings(t *T) {
 	// Headings with no content between them
 	content := `# Title
 ## Subtitle
@@ -666,31 +665,37 @@ func TestExtractSections_Good_ConsecutiveHeadings(t *testing.T) {
 
 	sections := ExtractSections(content)
 
-	require.Len(t, sections, 3)
+	AssertLen(t, sections, 3)
 	// First two sections should have empty content
-	assert.Equal(t, "", sections[0].Content)
-	assert.Equal(t, "", sections[1].Content)
-	assert.Equal(t, "", sections[2].Content)
+	AssertEqual(t, "", sections[0].Content)
+	AssertEqual(t, "", sections[1].Content)
+	AssertEqual(t, "", sections[2].Content)
 }
 
-func TestGenerateID_Ugly_EmptyString(t *testing.T) {
+func TestGenerateID_Ugly_EmptyString(t *T) {
 	result := GenerateID("")
-	assert.Equal(t, "", result)
+	AssertEqual(t, "", result)
+	AssertEmpty(t, result)
+	AssertNotContains(t, result, "-")
 }
 
-func TestGenerateID_Good_OnlySpecialChars(t *testing.T) {
+func TestGenerateID_Good_OnlySpecialChars(t *T) {
 	result := GenerateID("!@#$%^&*()")
-	assert.Equal(t, "", result)
+	AssertEqual(t, "", result)
+	AssertEmpty(t, result)
+	AssertNotContains(t, result, "!")
 }
 
-func TestGenerateID_Good_CJK(t *testing.T) {
+func TestGenerateID_Good_CJK(t *T) {
 	result := GenerateID("日本語テスト")
-	assert.NotEmpty(t, result)
-	assert.NotContains(t, result, " ")
+	AssertNotEmpty(t, result)
+	AssertNotContains(t, result, " ")
 }
 
-func TestGenerateID_Good_Emoji(t *testing.T) {
+func TestGenerateID_Good_Emoji(t *T) {
 	result := GenerateID("Hello 🌍 World")
 	// Emoji are not letters or digits, so they are dropped
-	assert.Equal(t, "hello-world", result)
+	AssertEqual(t, "hello-world", result)
+	AssertNotContains(t, result, "🌍")
+	AssertNotContains(t, result, " ")
 }
diff --git a/pkg/help/render_test.go b/pkg/help/render_test.go
index 5b41ac7..db48798 100644
--- a/pkg/help/render_test.go
+++ b/pkg/help/render_test.go
@@ -2,131 +2,128 @@
 package help
 
 import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	. "dappco.re/go"
 )
 
-func TestRenderMarkdown_Good(t *testing.T) {
-	t.Run("heading hierarchy H1-H6", func(t *testing.T) {
+func TestRenderMarkdown_Good(t *T) {
+	t.Run("heading hierarchy H1-H6", func(t *T) {
 		input := "# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<h1>H1</h1>")
-		assert.Contains(t, html, "<h2>H2</h2>")
-		assert.Contains(t, html, "<h3>H3</h3>")
-		assert.Contains(t, html, "<h4>H4</h4>")
-		assert.Contains(t, html, "<h5>H5</h5>")
-		assert.Contains(t, html, "<h6>H6</h6>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<h1>H1</h1>")
+		AssertContains(t, html, "<h2>H2</h2>")
+		AssertContains(t, html, "<h3>H3</h3>")
+		AssertContains(t, html, "<h4>H4</h4>")
+		AssertContains(t, html, "<h5>H5</h5>")
+		AssertContains(t, html, "<h6>H6</h6>")
 	})
 
-	t.Run("fenced code blocks with language", func(t *testing.T) {
+	t.Run("fenced code blocks with language", func(t *T) {
 		input := "```go\nfmt.Println(\"hello\")\n```\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<pre><code class=\"language-go\">")
-		assert.Contains(t, html, "fmt.Println")
-		assert.Contains(t, html, "</code></pre>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<pre><code class=\"language-go\">")
+		AssertContains(t, html, "fmt.Println")
+		AssertContains(t, html, "</code></pre>")
 	})
 
-	t.Run("inline code backticks", func(t *testing.T) {
+	t.Run("inline code backticks", func(t *T) {
 		input := "Use `go test` to run tests.\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<code>go test</code>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<code>go test</code>")
 	})
 
-	t.Run("unordered lists", func(t *testing.T) {
+	t.Run("unordered lists", func(t *T) {
 		input := "- Alpha\n- Beta\n- Gamma\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<ul>")
-		assert.Contains(t, html, "<li>Alpha</li>")
-		assert.Contains(t, html, "<li>Beta</li>")
-		assert.Contains(t, html, "<li>Gamma</li>")
-		assert.Contains(t, html, "</ul>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<ul>")
+		AssertContains(t, html, "<li>Alpha</li>")
+		AssertContains(t, html, "<li>Beta</li>")
+		AssertContains(t, html, "<li>Gamma</li>")
+		AssertContains(t, html, "</ul>")
 	})
 
-	t.Run("ordered lists", func(t *testing.T) {
+	t.Run("ordered lists", func(t *T) {
 		input := "1. First\n2. Second\n3. Third\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<ol>")
-		assert.Contains(t, html, "<li>First</li>")
-		assert.Contains(t, html, "<li>Second</li>")
-		assert.Contains(t, html, "<li>Third</li>")
-		assert.Contains(t, html, "</ol>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<ol>")
+		AssertContains(t, html, "<li>First</li>")
+		AssertContains(t, html, "<li>Second</li>")
+		AssertContains(t, html, "<li>Third</li>")
+		AssertContains(t, html, "</ol>")
 	})
 
-	t.Run("links and images", func(t *testing.T) {
+	t.Run("links and images", func(t *T) {
 		input := "[Example](https://example.com)\n\n![Alt text](image.png)\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, `<a href="https://example.com">Example</a>`)
-		assert.Contains(t, html, `<img src="image.png" alt="Alt text"`)
+		RequireNoError(t, err)
+		AssertContains(t, html, `<a href="https://example.com">Example</a>`)
+		AssertContains(t, html, `<img src="image.png" alt="Alt text"`)
 	})
 
-	t.Run("GFM tables", func(t *testing.T) {
+	t.Run("GFM tables", func(t *T) {
 		input := "| Name | Value |\n|------|-------|\n| foo  | 42    |\n| bar  | 99    |\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<table>")
-		assert.Contains(t, html, "<th>Name</th>")
-		assert.Contains(t, html, "<th>Value</th>")
-		assert.Contains(t, html, "<td>foo</td>")
-		assert.Contains(t, html, "<td>42</td>")
-		assert.Contains(t, html, "</table>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<table>")
+		AssertContains(t, html, "<th>Name</th>")
+		AssertContains(t, html, "<th>Value</th>")
+		AssertContains(t, html, "<td>foo</td>")
+		AssertContains(t, html, "<td>42</td>")
+		AssertContains(t, html, "</table>")
 	})
 
-	t.Run("empty input returns empty string", func(t *testing.T) {
+	t.Run("empty input returns empty string", func(t *T) {
 		html, err := RenderMarkdown("")
-		require.NoError(t, err)
-		assert.Equal(t, "", html)
+		RequireNoError(t, err)
+		AssertEqual(t, "", html)
 	})
 
-	t.Run("special characters escaped in text", func(t *testing.T) {
+	t.Run("special characters escaped in text", func(t *T) {
 		input := "Use `<div>` tags & \"quotes\".\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
+		RequireNoError(t, err)
 		// The & in prose should be escaped
-		assert.Contains(t, html, "&amp;")
+		AssertContains(t, html, "&amp;")
 		// Angle brackets in code should be escaped
-		assert.Contains(t, html, "&lt;div&gt;")
+		AssertContains(t, html, "&lt;div&gt;")
 	})
 }
 
-func TestRenderMarkdown_Good_RawHTML(t *testing.T) {
+func TestRenderMarkdown_Good_RawHTML(t *T) {
 	// html.WithUnsafe() should allow raw HTML pass-through
 	input := "<div class=\"custom\">raw html</div>\n"
 	html, err := RenderMarkdown(input)
-	require.NoError(t, err)
-	assert.Contains(t, html, `<div class="custom">raw html</div>`)
+	RequireNoError(t, err)
+	AssertContains(t, html, `<div class="custom">raw html</div>`)
 }
 
-func TestRenderMarkdown_Good_GFMExtras(t *testing.T) {
-	t.Run("strikethrough", func(t *testing.T) {
+func TestRenderMarkdown_Good_GFMExtras(t *T) {
+	t.Run("strikethrough", func(t *T) {
 		input := "~~deleted~~\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, "<del>deleted</del>")
+		RequireNoError(t, err)
+		AssertContains(t, html, "<del>deleted</del>")
 	})
 
-	t.Run("autolinks", func(t *testing.T) {
+	t.Run("autolinks", func(t *T) {
 		input := "Visit https://example.com for details.\n"
 		html, err := RenderMarkdown(input)
-		require.NoError(t, err)
-		assert.Contains(t, html, `<a href="https://example.com">`)
+		RequireNoError(t, err)
+		AssertContains(t, html, `<a href="https://example.com">`)
 	})
 }
 
-func TestRenderMarkdown_Good_Typographer(t *testing.T) {
+func TestRenderMarkdown_Good_Typographer(t *T) {
 	// Typographer extension converts straight quotes to smart quotes
 	// and -- to en-dash, --- to em-dash.
 	input := "She said -- \"hello\" --- and left.\n"
 	html, err := RenderMarkdown(input)
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	// Check that dashes are converted (en-dash or em-dash entities)
-	assert.NotContains(t, html, " -- ")
-	assert.NotContains(t, html, " --- ")
+	AssertNotContains(t, html, " -- ")
+	AssertNotContains(t, html, " --- ")
 }
diff --git a/pkg/help/search_bench_test.go b/pkg/help/search_bench_test.go
index 8d6fe3c..74c19b5 100644
--- a/pkg/help/search_bench_test.go
+++ b/pkg/help/search_bench_test.go
@@ -2,9 +2,9 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"fmt"
 	"strings"
-	"testing"
 )
 
 // titleCase capitalises the first letter of a string.
@@ -83,7 +83,7 @@ func buildLargeCatalog(n int) *searchIndex {
 	return idx
 }
 
-func BenchmarkSearch_SingleWord(b *testing.B) {
+func BenchmarkSearch_SingleWord(b *B) {
 	idx := buildLargeCatalog(200)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -93,7 +93,7 @@ func BenchmarkSearch_SingleWord(b *testing.B) {
 	}
 }
 
-func BenchmarkSearch_MultiWord(b *testing.B) {
+func BenchmarkSearch_MultiWord(b *B) {
 	idx := buildLargeCatalog(200)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -103,7 +103,7 @@ func BenchmarkSearch_MultiWord(b *testing.B) {
 	}
 }
 
-func BenchmarkSearch_NoResults(b *testing.B) {
+func BenchmarkSearch_NoResults(b *B) {
 	idx := buildLargeCatalog(200)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -113,7 +113,7 @@ func BenchmarkSearch_NoResults(b *testing.B) {
 	}
 }
 
-func BenchmarkSearch_PartialMatch(b *testing.B) {
+func BenchmarkSearch_PartialMatch(b *B) {
 	idx := buildLargeCatalog(200)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -123,7 +123,7 @@ func BenchmarkSearch_PartialMatch(b *testing.B) {
 	}
 }
 
-func BenchmarkSearch_LargeCatalog500(b *testing.B) {
+func BenchmarkSearch_LargeCatalog500(b *B) {
 	idx := buildLargeCatalog(500)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -133,7 +133,7 @@ func BenchmarkSearch_LargeCatalog500(b *testing.B) {
 	}
 }
 
-func BenchmarkSearch_LargeCatalog1000(b *testing.B) {
+func BenchmarkSearch_LargeCatalog1000(b *B) {
 	idx := buildLargeCatalog(1000)
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -143,7 +143,7 @@ func BenchmarkSearch_LargeCatalog1000(b *testing.B) {
 	}
 }
 
-func BenchmarkSearchIndex_Add(b *testing.B) {
+func BenchmarkSearchIndex_Add(b *B) {
 	// Benchmark the indexing/add path
 	topic := &Topic{
 		ID:      "bench-topic",
@@ -165,7 +165,7 @@ func BenchmarkSearchIndex_Add(b *testing.B) {
 	}
 }
 
-func BenchmarkTokenize(b *testing.B) {
+func BenchmarkTokenize(b *B) {
 	text := "The quick brown fox jumps over the lazy dog. Configuration and deployment are covered in detail."
 	b.ReportAllocs()
 	b.ResetTimer()
diff --git a/pkg/help/search_test.go b/pkg/help/search_test.go
index 109fc88..aef8c22 100644
--- a/pkg/help/search_test.go
+++ b/pkg/help/search_test.go
@@ -2,16 +2,13 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"regexp"
 	"strings"
-	"testing"
 	"unicode/utf8"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestTokenize_Good(t *testing.T) {
+func TestTokenize_Good(t *T) {
 	tests := []struct {
 		name     string
 		input    string
@@ -55,14 +52,14 @@ func TestTokenize_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			result := tokenize(tt.input)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
-func TestSearchIndex_Add_Good(t *testing.T) {
+func TestSearchIndex_Add_Good(t *T) {
 	idx := newSearchIndex()
 
 	topic := &Topic{
@@ -78,20 +75,20 @@ func TestSearchIndex_Add_Good(t *testing.T) {
 	idx.Add(topic)
 
 	// Verify topic is stored
-	assert.NotNil(t, idx.topics["getting-started"])
+	AssertNotNil(t, idx.topics["getting-started"])
 
 	// Verify words are indexed
-	assert.Contains(t, idx.index["getting"], "getting-started")
-	assert.Contains(t, idx.index["started"], "getting-started")
-	assert.Contains(t, idx.index["welcome"], "getting-started")
-	assert.Contains(t, idx.index["guide"], "getting-started")
-	assert.Contains(t, idx.index["intro"], "getting-started")
-	assert.Contains(t, idx.index["setup"], "getting-started")
-	assert.Contains(t, idx.index["installation"], "getting-started")
-	assert.Contains(t, idx.index["cli"], "getting-started")
+	AssertContains(t, idx.index["getting"], "getting-started")
+	AssertContains(t, idx.index["started"], "getting-started")
+	AssertContains(t, idx.index["welcome"], "getting-started")
+	AssertContains(t, idx.index["guide"], "getting-started")
+	AssertContains(t, idx.index["intro"], "getting-started")
+	AssertContains(t, idx.index["setup"], "getting-started")
+	AssertContains(t, idx.index["installation"], "getting-started")
+	AssertContains(t, idx.index["cli"], "getting-started")
 }
 
-func TestSearchIndex_Search_Good(t *testing.T) {
+func TestSearchIndex_Search_Good(t *T) {
 	idx := newSearchIndex()
 
 	// Add test topics
@@ -114,29 +111,29 @@ func TestSearchIndex_Search_Good(t *testing.T) {
 		Content: "List of all available commands.",
 	})
 
-	t.Run("single word query", func(t *testing.T) {
+	t.Run("single word query", func(t *T) {
 		results := idx.Search("configuration")
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "configuration", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "configuration", results[0].Topic.ID)
 	})
 
-	t.Run("multi-word query", func(t *testing.T) {
+	t.Run("multi-word query", func(t *T) {
 		results := idx.Search("cli guide")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 		// Should match getting-started (has both "cli" and "guide")
-		assert.Equal(t, "getting-started", results[0].Topic.ID)
+		AssertEqual(t, "getting-started", results[0].Topic.ID)
 	})
 
-	t.Run("title boost", func(t *testing.T) {
+	t.Run("title boost", func(t *T) {
 		results := idx.Search("commands")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 		// "commands" appears in title of commands topic
-		assert.Equal(t, "commands", results[0].Topic.ID)
+		AssertEqual(t, "commands", results[0].Topic.ID)
 	})
 
-	t.Run("partial word matching", func(t *testing.T) {
+	t.Run("partial word matching", func(t *T) {
 		results := idx.Search("config")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 		// Should match "configuration" and "configure"
 		foundConfig := false
 		for _, r := range results {
@@ -145,21 +142,21 @@ func TestSearchIndex_Search_Good(t *testing.T) {
 				break
 			}
 		}
-		assert.True(t, foundConfig, "Should find configuration topic with prefix match")
+		AssertTrue(t, foundConfig, "Should find configuration topic with prefix match")
 	})
 
-	t.Run("no results", func(t *testing.T) {
+	t.Run("no results", func(t *T) {
 		results := idx.Search("nonexistent")
-		assert.Empty(t, results)
+		AssertEmpty(t, results)
 	})
 
-	t.Run("empty query", func(t *testing.T) {
+	t.Run("empty query", func(t *T) {
 		results := idx.Search("")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 }
 
-func TestSearchIndex_Search_Good_WithSections(t *testing.T) {
+func TestSearchIndex_Search_Good_WithSections(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -185,24 +182,24 @@ func TestSearchIndex_Search_Good_WithSections(t *testing.T) {
 		},
 	})
 
-	t.Run("matches section content", func(t *testing.T) {
+	t.Run("matches section content", func(t *T) {
 		results := idx.Search("debian")
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "installation", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "installation", results[0].Topic.ID)
 		// Should identify the Linux section as best match
 		if results[0].Section != nil {
-			assert.Equal(t, "linux", results[0].Section.ID)
+			AssertEqual(t, "linux", results[0].Section.ID)
 		}
 	})
 
-	t.Run("matches section title", func(t *testing.T) {
+	t.Run("matches section title", func(t *T) {
 		results := idx.Search("windows")
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "installation", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "installation", results[0].Topic.ID)
 	})
 }
 
-func TestExtractSnippet_Good(t *testing.T) {
+func TestExtractSnippet_Good(t *T) {
 	content := `This is the first paragraph with some introduction text.
 
 Here is more content that talks about installation and setup.
@@ -210,69 +207,69 @@ The installation process is straightforward.
 
 Finally, some closing remarks about the configuration.`
 
-	t.Run("finds match and extracts context", func(t *testing.T) {
+	t.Run("finds match and extracts context", func(t *T) {
 		snippet := extractSnippet(content, compileRegexes([]string{"installation"}))
-		assert.Contains(t, snippet, "**installation**")
-		assert.True(t, len(snippet) <= 250, "Snippet should be reasonably short")
+		AssertContains(t, snippet, "**installation**")
+		AssertTrue(t, len(snippet) <= 250, "Snippet should be reasonably short")
 	})
 
-	t.Run("no query words returns start", func(t *testing.T) {
+	t.Run("no query words returns start", func(t *T) {
 		snippet := extractSnippet(content, nil)
-		assert.Contains(t, snippet, "first paragraph")
+		AssertContains(t, snippet, "first paragraph")
 	})
 
-	t.Run("empty content", func(t *testing.T) {
+	t.Run("empty content", func(t *T) {
 		snippet := extractSnippet("", compileRegexes([]string{"test"}))
-		assert.Empty(t, snippet)
+		AssertEmpty(t, snippet)
 	})
 }
 
-func TestExtractSnippet_Highlighting(t *testing.T) {
+func TestExtractSnippet_Highlighting(t *T) {
 	content := "The quick brown fox jumps over the lazy dog."
 
-	t.Run("simple highlighting", func(t *testing.T) {
+	t.Run("simple highlighting", func(t *T) {
 		snippet := extractSnippet(content, compileRegexes([]string{"quick", "fox"}))
-		assert.Contains(t, snippet, "**quick**")
-		assert.Contains(t, snippet, "**fox**")
+		AssertContains(t, snippet, "**quick**")
+		AssertContains(t, snippet, "**fox**")
 	})
 
-	t.Run("case insensitive highlighting", func(t *testing.T) {
+	t.Run("case insensitive highlighting", func(t *T) {
 		snippet := extractSnippet(content, compileRegexes([]string{"QUICK", "Fox"}))
-		assert.Contains(t, snippet, "**quick**")
-		assert.Contains(t, snippet, "**fox**")
+		AssertContains(t, snippet, "**quick**")
+		AssertContains(t, snippet, "**fox**")
 	})
 
-	t.Run("partial word matching", func(t *testing.T) {
+	t.Run("partial word matching", func(t *T) {
 		content := "The configuration is complete."
 		snippet := extractSnippet(content, compileRegexes([]string{"config"}))
-		assert.Contains(t, snippet, "**config**uration")
+		AssertContains(t, snippet, "**config**uration")
 	})
 
-	t.Run("overlapping matches", func(t *testing.T) {
+	t.Run("overlapping matches", func(t *T) {
 		content := "Searching for something."
 		// Both "search" and "searching" match
 		snippet := extractSnippet(content, compileRegexes([]string{"search", "searching"}))
-		assert.Equal(t, "**Searching** for something.", snippet)
+		AssertEqual(t, "**Searching** for something.", snippet)
 	})
 }
 
-func TestExtractSnippet_Good_UTF8(t *testing.T) {
+func TestExtractSnippet_Good_UTF8(t *T) {
 	// Content with multi-byte UTF-8 characters
 	content := "日本語のテキストです。This contains Japanese text. 検索機能をテストします。"
 
-	t.Run("handles multi-byte characters without corruption", func(t *testing.T) {
+	t.Run("handles multi-byte characters without corruption", func(t *T) {
 		snippet := extractSnippet(content, compileRegexes([]string{"japanese"}))
 		// Should not panic or produce invalid UTF-8
-		assert.True(t, len(snippet) > 0)
+		AssertTrue(t, len(snippet) > 0)
 		// Verify the result is valid UTF-8
-		assert.True(t, isValidUTF8(snippet), "Snippet should be valid UTF-8")
+		AssertTrue(t, isValidUTF8(snippet), "Snippet should be valid UTF-8")
 	})
 
-	t.Run("truncates multi-byte content safely", func(t *testing.T) {
+	t.Run("truncates multi-byte content safely", func(t *T) {
 		// Long content that will be truncated
 		longContent := strings.Repeat("日本語", 100) // 300 characters
 		snippet := extractSnippet(longContent, nil)
-		assert.True(t, isValidUTF8(snippet), "Truncated snippet should be valid UTF-8")
+		AssertTrue(t, isValidUTF8(snippet), "Truncated snippet should be valid UTF-8")
 	})
 }
 
@@ -299,7 +296,7 @@ func isValidUTF8(s string) bool {
 	return true
 }
 
-func TestCountMatches_Good(t *testing.T) {
+func TestCountMatches_Good(t *T) {
 	tests := []struct {
 		text     string
 		words    []string
@@ -313,11 +310,11 @@ func TestCountMatches_Good(t *testing.T) {
 
 	for _, tt := range tests {
 		result := countMatches(tt.text, tt.words)
-		assert.Equal(t, tt.expected, result)
+		AssertEqual(t, tt.expected, result)
 	}
 }
 
-func TestSearchResult_Score_Good(t *testing.T) {
+func TestSearchResult_Score_Good(t *T) {
 	idx := newSearchIndex()
 
 	// Topic with query word in title should score higher
@@ -334,44 +331,44 @@ func TestSearchResult_Score_Good(t *testing.T) {
 	})
 
 	results := idx.Search("installation")
-	assert.Len(t, results, 2)
+	AssertLen(t, results, 2)
 
 	// Title match should score higher
-	assert.Equal(t, "topic-in-title", results[0].Topic.ID)
-	assert.Greater(t, results[0].Score, results[1].Score)
+	AssertEqual(t, "topic-in-title", results[0].Topic.ID)
+	AssertGreater(t, results[0].Score, results[1].Score)
 }
 
 // --- Upstream Phase 0 tests (100% coverage) ---
 
-func TestExtractSnippet_Good_HeadingsOnly(t *testing.T) {
+func TestExtractSnippet_Good_HeadingsOnly(t *T) {
 	// Content with only headings and no body text should return empty snippet
 	// when no regexes are provided. Covers the empty-return branch.
 	content := "# Heading One\n## Heading Two\n### Heading Three"
 
 	snippet := extractSnippet(content, nil)
-	assert.Empty(t, snippet, "headings-only content without regexes should return empty snippet")
+	AssertEmpty(t, snippet, "headings-only content without regexes should return empty snippet")
 }
 
-func TestExtractSnippet_Good_SnippetTrimmedToEmpty(t *testing.T) {
+func TestExtractSnippet_Good_SnippetTrimmedToEmpty(t *T) {
 	// After word-boundary trimming the snippet could become empty.
 	// This exercises the snippet=="" guard after TrimSpace.
 	content := strings.Repeat(" ", 200)
 
 	snippet := extractSnippet(content, compileRegexes([]string{"zz"}))
-	assert.Empty(t, snippet, "whitespace-only content should yield empty snippet")
+	AssertEmpty(t, snippet, "whitespace-only content should yield empty snippet")
 }
 
-func TestHighlight_Good_EmptyRegexes(t *testing.T) {
+func TestHighlight_Good_EmptyRegexes(t *T) {
 	// Calling highlight with an empty regex slice should return the
 	// text unchanged. Covers the early-return branch.
 	result := highlight("some text here", nil)
-	assert.Equal(t, "some text here", result)
+	AssertEqual(t, "some text here", result)
 
 	result = highlight("some text here", []*regexp.Regexp{})
-	assert.Equal(t, "some text here", result)
+	AssertEqual(t, "some text here", result)
 }
 
-func TestHighlight_Good_OverlappingExtension(t *testing.T) {
+func TestHighlight_Good_OverlappingExtension(t *T) {
 	// Test overlapping matches where the second match extends past the
 	// first, exercising the curr.end extension branch in merging.
 	text := "abcdefghij"
@@ -382,10 +379,10 @@ func TestHighlight_Good_OverlappingExtension(t *testing.T) {
 	re2, _ := regexp.Compile("cdefghij")
 
 	result := highlight(text, []*regexp.Regexp{re1, re2})
-	assert.Equal(t, "**abcdefghij**", result)
+	AssertEqual(t, "**abcdefghij**", result)
 }
 
-func TestSearchIndex_Search_Good_NilTopicGuard(t *testing.T) {
+func TestSearchIndex_Search_Good_NilTopicGuard(t *T) {
 	// Manually inject a stale reference in the scores map so the
 	// nil-topic guard is exercised. We do this by manipulating the
 	// index directly.
@@ -402,11 +399,11 @@ func TestSearchIndex_Search_Good_NilTopicGuard(t *testing.T) {
 
 	results := idx.Search("testword")
 	// Should still find the real topic, ghost-topic should be skipped.
-	assert.Len(t, results, 1)
-	assert.Equal(t, "real-topic", results[0].Topic.ID)
+	AssertLen(t, results, 1)
+	AssertEqual(t, "real-topic", results[0].Topic.ID)
 }
 
-func TestSearchIndex_Search_Good_SpecialCharacters(t *testing.T) {
+func TestSearchIndex_Search_Good_SpecialCharacters(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -415,19 +412,19 @@ func TestSearchIndex_Search_Good_SpecialCharacters(t *testing.T) {
 		Content: "Configure rate-limiting rules with special characters: @#$%.",
 	})
 
-	t.Run("query with special characters", func(t *testing.T) {
+	t.Run("query with special characters", func(t *T) {
 		results := idx.Search("rate limiting")
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "special-chars", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "special-chars", results[0].Topic.ID)
 	})
 
-	t.Run("query with punctuation stripped", func(t *testing.T) {
+	t.Run("query with punctuation stripped", func(t *T) {
 		results := idx.Search("v2.0")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 	})
 }
 
-func TestSearchIndex_Search_Good_CaseInsensitive(t *testing.T) {
+func TestSearchIndex_Search_Good_CaseInsensitive(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -436,19 +433,19 @@ func TestSearchIndex_Search_Good_CaseInsensitive(t *testing.T) {
 		Content: "MiXeD CaSe content here.",
 	})
 
-	t.Run("lowercase query finds uppercase content", func(t *testing.T) {
+	t.Run("lowercase query finds uppercase content", func(t *T) {
 		results := idx.Search("uppercase")
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "case-test", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "case-test", results[0].Topic.ID)
 	})
 
-	t.Run("uppercase query finds content", func(t *testing.T) {
+	t.Run("uppercase query finds content", func(t *T) {
 		results := idx.Search("MIXED")
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 	})
 }
 
-func TestSearchIndex_Search_Good_SingleCharQuery(t *testing.T) {
+func TestSearchIndex_Search_Good_SingleCharQuery(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -460,12 +457,12 @@ func TestSearchIndex_Search_Good_SingleCharQuery(t *testing.T) {
 	// Single-character queries are filtered out by tokenize (min 2 chars),
 	// so searching for "a" should return nil.
 	results := idx.Search("a")
-	assert.Nil(t, results)
+	AssertNil(t, results)
 }
 
 // --- Phase 1: Fuzzy matching tests ---
 
-func TestLevenshtein_Good(t *testing.T) {
+func TestLevenshtein_Good(t *T) {
 	tests := []struct {
 		name     string
 		a        string
@@ -488,14 +485,14 @@ func TestLevenshtein_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			result := levenshtein(tt.a, tt.b)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
-func TestMin3_Good(t *testing.T) {
+func TestMin3_Good(t *T) {
 	tests := []struct {
 		name     string
 		a, b, c  int
@@ -512,14 +509,14 @@ func TestMin3_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			result := min(tt.a, tt.b, tt.c)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
-func TestSearchIndex_Search_Good_FuzzyMatching(t *testing.T) {
+func TestSearchIndex_Search_Good_FuzzyMatching(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -534,10 +531,10 @@ func TestSearchIndex_Search_Good_FuzzyMatching(t *testing.T) {
 		Content: "Deploy your application to production servers.",
 	})
 
-	t.Run("typo in query finds correct topic", func(t *testing.T) {
+	t.Run("typo in query finds correct topic", func(t *T) {
 		// "configuraton" is 1 edit away from "configuration"
 		results := idx.Search("configuraton")
-		assert.NotEmpty(t, results, "fuzzy match should find results for typo")
+		AssertNotEmpty(t, results, "fuzzy match should find results for typo")
 		found := false
 		for _, r := range results {
 			if r.Topic.ID == "configuration" {
@@ -545,23 +542,23 @@ func TestSearchIndex_Search_Good_FuzzyMatching(t *testing.T) {
 				break
 			}
 		}
-		assert.True(t, found, "should find configuration topic with typo")
+		AssertTrue(t, found, "should find configuration topic with typo")
 	})
 
-	t.Run("two-edit typo still matches", func(t *testing.T) {
+	t.Run("two-edit typo still matches", func(t *T) {
 		// "deplymnt" is within 2 edits of "deployment" -- but first check
 		// that "deploymnt" (1 edit) works.
 		results := idx.Search("deploymnt")
-		assert.NotEmpty(t, results, "fuzzy match should find results for 1-edit typo")
+		AssertNotEmpty(t, results, "fuzzy match should find results for 1-edit typo")
 	})
 
-	t.Run("too many edits returns no fuzzy match", func(t *testing.T) {
+	t.Run("too many edits returns no fuzzy match", func(t *T) {
 		// "zzzzzzz" is very far from any indexed word.
 		results := idx.Search("zzzzzzz")
-		assert.Empty(t, results, "large edit distance should not produce results")
+		AssertEmpty(t, results, "large edit distance should not produce results")
 	})
 
-	t.Run("short words skip fuzzy matching", func(t *testing.T) {
+	t.Run("short words skip fuzzy matching", func(t *T) {
 		// Words shorter than 3 characters skip fuzzy matching.
 		// "to" is in the index but "tx" (1 edit) should not fuzzy-match
 		// because "tx" is only 2 chars.
@@ -570,13 +567,13 @@ func TestSearchIndex_Search_Good_FuzzyMatching(t *testing.T) {
 		_ = results
 	})
 
-	t.Run("fuzzy scores lower than exact", func(t *testing.T) {
+	t.Run("fuzzy scores lower than exact", func(t *T) {
 		// Exact match on "configure" should score higher than fuzzy.
 		exactResults := idx.Search("configure")
 		fuzzyResults := idx.Search("configurr")
 
 		if len(exactResults) > 0 && len(fuzzyResults) > 0 {
-			assert.GreaterOrEqual(t, exactResults[0].Score, fuzzyResults[0].Score,
+			AssertGreaterOrEqual(t, exactResults[0].Score, fuzzyResults[0].Score,
 				"exact match should score at least as high as fuzzy match")
 		}
 	})
@@ -584,7 +581,7 @@ func TestSearchIndex_Search_Good_FuzzyMatching(t *testing.T) {
 
 // --- Phase 1: Phrase search tests ---
 
-func TestExtractPhrases_Good(t *testing.T) {
+func TestExtractPhrases_Good(t *T) {
 	tests := []struct {
 		name              string
 		query             string
@@ -636,15 +633,15 @@ func TestExtractPhrases_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			phrases, remaining := extractPhrases(tt.query)
-			assert.Equal(t, tt.expectedPhrases, phrases)
-			assert.Equal(t, tt.expectedRemaining, remaining)
+			AssertEqual(t, tt.expectedPhrases, phrases)
+			AssertEqual(t, tt.expectedRemaining, remaining)
 		})
 	}
 }
 
-func TestSearchIndex_Search_Good_PhraseSearch(t *testing.T) {
+func TestSearchIndex_Search_Good_PhraseSearch(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -661,38 +658,38 @@ func TestSearchIndex_Search_Good_PhraseSearch(t *testing.T) {
 		Tags:    []string{"errors"},
 	})
 
-	t.Run("quoted phrase matches exact sequence", func(t *testing.T) {
+	t.Run("quoted phrase matches exact sequence", func(t *T) {
 		results := idx.Search(`"rate limit"`)
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 		// rate-limiting topic has "rate limit" as exact phrase
-		assert.Equal(t, "rate-limiting", results[0].Topic.ID)
+		AssertEqual(t, "rate-limiting", results[0].Topic.ID)
 	})
 
-	t.Run("unquoted words match both topics", func(t *testing.T) {
+	t.Run("unquoted words match both topics", func(t *T) {
 		results := idx.Search("rate limit")
-		assert.GreaterOrEqual(t, len(results), 2,
+		AssertGreaterOrEqual(t, len(results), 2,
 			"unquoted query should match both topics that contain the words separately")
 	})
 
-	t.Run("phrase not found yields no phrase boost", func(t *testing.T) {
+	t.Run("phrase not found yields no phrase boost", func(t *T) {
 		results := idx.Search(`"nonexistent phrase here"`)
-		assert.Empty(t, results, "phrase with no tokenisable words and no match should return empty")
+		AssertEmpty(t, results, "phrase with no tokenisable words and no match should return empty")
 	})
 
-	t.Run("phrase with surrounding keywords", func(t *testing.T) {
+	t.Run("phrase with surrounding keywords", func(t *T) {
 		results := idx.Search(`"rate limit" api`)
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "rate-limiting", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "rate-limiting", results[0].Topic.ID)
 	})
 
-	t.Run("phrase-only query with no loose words", func(t *testing.T) {
+	t.Run("phrase-only query with no loose words", func(t *T) {
 		// Query is only a quoted phrase; tokenize of remaining is empty,
 		// but phrase matching should still score topics.
 		results := idx.Search(`"rate limit"`)
-		assert.NotEmpty(t, results)
+		AssertNotEmpty(t, results)
 	})
 
-	t.Run("phrase found in section content", func(t *testing.T) {
+	t.Run("phrase found in section content", func(t *T) {
 		sectionIdx := newSearchIndex()
 		sectionIdx.Add(&Topic{
 			ID:      "section-phrase",
@@ -708,14 +705,14 @@ func TestSearchIndex_Search_Good_PhraseSearch(t *testing.T) {
 		})
 
 		results := sectionIdx.Search(`"rate limit"`)
-		assert.NotEmpty(t, results)
-		assert.Equal(t, "section-phrase", results[0].Topic.ID)
+		AssertNotEmpty(t, results)
+		AssertEqual(t, "section-phrase", results[0].Topic.ID)
 	})
 }
 
 // --- Phase 1: Improved scoring tests ---
 
-func TestSearchIndex_Search_Good_TagBoost(t *testing.T) {
+func TestSearchIndex_Search_Good_TagBoost(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -732,14 +729,14 @@ func TestSearchIndex_Search_Good_TagBoost(t *testing.T) {
 	})
 
 	results := idx.Search("deployment")
-	assert.NotEmpty(t, results)
+	AssertNotEmpty(t, results)
 
 	// The tagged topic should rank higher because of the tag boost.
-	assert.Equal(t, "tagged-topic", results[0].Topic.ID,
+	AssertEqual(t, "tagged-topic", results[0].Topic.ID,
 		"topic with matching tag should rank higher")
 }
 
-func TestSearchIndex_Search_Good_MultiWordBonus(t *testing.T) {
+func TestSearchIndex_Search_Good_MultiWordBonus(t *T) {
 	idx := newSearchIndex()
 
 	// Both topics have neutral titles (no query words in title) to
@@ -757,28 +754,28 @@ func TestSearchIndex_Search_Good_MultiWordBonus(t *testing.T) {
 	})
 
 	results := idx.Search("deploying monitoring")
-	assert.NotEmpty(t, results)
+	AssertNotEmpty(t, results)
 
 	// Topic with both words should score higher due to multi-word bonus.
-	assert.Equal(t, "both-words", results[0].Topic.ID,
+	AssertEqual(t, "both-words", results[0].Topic.ID,
 		"topic containing all query words should rank higher")
 }
 
-func TestSearchIndex_Search_Good_ScoringConstants(t *testing.T) {
+func TestSearchIndex_Search_Good_ScoringConstants(t *T) {
 	// Verify the scoring constants are sensible relative to each other.
-	assert.Greater(t, scoreTitleBoost, scoreSectionBoost,
+	AssertGreater(t, scoreTitleBoost, scoreSectionBoost,
 		"title boost should exceed section boost")
-	assert.Greater(t, scoreSectionBoost, scoreTagBoost,
+	AssertGreater(t, scoreSectionBoost, scoreTagBoost,
 		"section boost should exceed tag boost")
-	assert.Greater(t, scoreExactWord, scorePrefixWord,
+	AssertGreater(t, scoreExactWord, scorePrefixWord,
 		"exact match should score higher than prefix match")
-	assert.Greater(t, scorePrefixWord, scoreFuzzyWord,
+	AssertGreater(t, scorePrefixWord, scoreFuzzyWord,
 		"prefix match should score higher than fuzzy match")
-	assert.Greater(t, scorePhraseBoost, scoreAllWords,
+	AssertGreater(t, scorePhraseBoost, scoreAllWords,
 		"phrase boost should exceed multi-word bonus")
 }
 
-func TestSearchIndex_Search_Good_PhraseHighlighting(t *testing.T) {
+func TestSearchIndex_Search_Good_PhraseHighlighting(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -788,44 +785,44 @@ func TestSearchIndex_Search_Good_PhraseHighlighting(t *testing.T) {
 	})
 
 	results := idx.Search(`"rate limit" api`)
-	assert.NotEmpty(t, results)
+	AssertNotEmpty(t, results)
 
 	// The snippet should highlight both the phrase and keyword.
 	if results[0].Snippet != "" {
-		assert.Contains(t, results[0].Snippet, "**rate limit**",
+		AssertContains(t, results[0].Snippet, "**rate limit**",
 			"phrase should be highlighted in snippet")
 	}
 }
 
 // --- Phase 0 additional tests: expanded edge cases ---
 
-func TestSearchIndex_Search_Bad_EmptyQuery(t *testing.T) {
+func TestSearchIndex_Search_Bad_EmptyQuery(t *T) {
 	idx := newSearchIndex()
 	idx.Add(&Topic{ID: "test", Title: "Test Topic", Content: "Some content."})
 
-	t.Run("empty string", func(t *testing.T) {
+	t.Run("empty string", func(t *T) {
 		results := idx.Search("")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 
-	t.Run("whitespace only", func(t *testing.T) {
+	t.Run("whitespace only", func(t *T) {
 		results := idx.Search("   ")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 
-	t.Run("single character", func(t *testing.T) {
+	t.Run("single character", func(t *T) {
 		// Single chars are filtered by tokenize (min 2 chars)
 		results := idx.Search("a")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 
-	t.Run("punctuation only", func(t *testing.T) {
+	t.Run("punctuation only", func(t *T) {
 		results := idx.Search("!@#$%")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 }
 
-func TestSearchIndex_Search_Bad_NoResults(t *testing.T) {
+func TestSearchIndex_Search_Bad_NoResults(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -834,19 +831,19 @@ func TestSearchIndex_Search_Bad_NoResults(t *testing.T) {
 		Content: "Building applications with Go and goroutines.",
 	})
 
-	t.Run("completely unrelated query", func(t *testing.T) {
+	t.Run("completely unrelated query", func(t *T) {
 		results := idx.Search("quantum physics")
-		assert.Empty(t, results)
+		AssertEmpty(t, results)
 	})
 
-	t.Run("empty index", func(t *testing.T) {
+	t.Run("empty index", func(t *T) {
 		emptyIdx := newSearchIndex()
 		results := emptyIdx.Search("anything")
-		assert.Empty(t, results)
+		AssertEmpty(t, results)
 	})
 }
 
-func TestSearchIndex_Search_Good_CaseSensitivity(t *testing.T) {
+func TestSearchIndex_Search_Good_CaseSensitivity(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -855,32 +852,32 @@ func TestSearchIndex_Search_Good_CaseSensitivity(t *testing.T) {
 		Content: "Configure POSTGRESQL settings. The postgresql.conf file controls everything.",
 	})
 
-	t.Run("lowercase query matches uppercase content", func(t *testing.T) {
+	t.Run("lowercase query matches uppercase content", func(t *T) {
 		results := idx.Search("postgresql")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "case-test", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "case-test", results[0].Topic.ID)
 	})
 
-	t.Run("uppercase query matches lowercase content", func(t *testing.T) {
+	t.Run("uppercase query matches lowercase content", func(t *T) {
 		results := idx.Search("POSTGRESQL")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "case-test", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "case-test", results[0].Topic.ID)
 	})
 
-	t.Run("mixed case query matches", func(t *testing.T) {
+	t.Run("mixed case query matches", func(t *T) {
 		results := idx.Search("PostgreSQL")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "case-test", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "case-test", results[0].Topic.ID)
 	})
 
-	t.Run("title case sensitivity", func(t *testing.T) {
+	t.Run("title case sensitivity", func(t *T) {
 		results := idx.Search("configuration")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "case-test", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "case-test", results[0].Topic.ID)
 	})
 }
 
-func TestSearchIndex_Search_Good_MultiWord(t *testing.T) {
+func TestSearchIndex_Search_Good_MultiWord(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -899,38 +896,38 @@ func TestSearchIndex_Search_Good_MultiWord(t *testing.T) {
 		Content: "Setting up a Kubernetes cluster for production.",
 	})
 
-	t.Run("both words match same topic", func(t *testing.T) {
+	t.Run("both words match same topic", func(t *T) {
 		results := idx.Search("docker compose")
-		require.NotEmpty(t, results)
+		RequireNotEmpty(t, results)
 		// docker-compose should rank highest (both words in title + content)
-		assert.Equal(t, "docker-compose", results[0].Topic.ID)
+		AssertEqual(t, "docker-compose", results[0].Topic.ID)
 	})
 
-	t.Run("one word matches multiple topics", func(t *testing.T) {
+	t.Run("one word matches multiple topics", func(t *T) {
 		results := idx.Search("docker")
-		require.Len(t, results, 2)
+		AssertLen(t, results, 2)
 		// Both docker topics should appear
 		ids := []string{results[0].Topic.ID, results[1].Topic.ID}
-		assert.Contains(t, ids, "docker-compose")
-		assert.Contains(t, ids, "docker-basics")
+		AssertContains(t, ids, "docker-compose")
+		AssertContains(t, ids, "docker-basics")
 	})
 
-	t.Run("words from different topics", func(t *testing.T) {
+	t.Run("words from different topics", func(t *T) {
 		results := idx.Search("docker kubernetes")
-		require.NotEmpty(t, results)
+		RequireNotEmpty(t, results)
 		// All three topics should match (docker matches 2, kubernetes matches 1)
-		assert.GreaterOrEqual(t, len(results), 3)
+		AssertGreaterOrEqual(t, len(results), 3)
 	})
 
-	t.Run("three word query narrows results", func(t *testing.T) {
+	t.Run("three word query narrows results", func(t *T) {
 		results := idx.Search("docker compose setup")
-		require.NotEmpty(t, results)
+		RequireNotEmpty(t, results)
 		// docker-compose has all three words, should rank first
-		assert.Equal(t, "docker-compose", results[0].Topic.ID)
+		AssertEqual(t, "docker-compose", results[0].Topic.ID)
 	})
 }
 
-func TestSearchIndex_Search_Good_SpecialCharsExpanded(t *testing.T) {
+func TestSearchIndex_Search_Good_SpecialCharsExpanded(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -949,29 +946,29 @@ func TestSearchIndex_Search_Good_SpecialCharsExpanded(t *testing.T) {
 		Content: "Use @username to mention users in comments.",
 	})
 
-	t.Run("query with at symbol", func(t *testing.T) {
+	t.Run("query with at symbol", func(t *T) {
 		// "@username" tokenises to "username" (@ is stripped)
 		results := idx.Search("@username")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "at-mentions", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "at-mentions", results[0].Topic.ID)
 	})
 
-	t.Run("query with dots", func(t *testing.T) {
+	t.Run("query with dots", func(t *T) {
 		// "smtp.example.com" tokenises to "smtp", "example", "com"
 		results := idx.Search("smtp.example.com")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "email-config", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "email-config", results[0].Topic.ID)
 	})
 
-	t.Run("query with underscores", func(t *testing.T) {
+	t.Run("query with underscores", func(t *T) {
 		// "SMTP_HOST" tokenises to "smtp", "host"
 		results := idx.Search("SMTP_HOST")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "email-config", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "email-config", results[0].Topic.ID)
 	})
 }
 
-func TestSearchIndex_Search_Good_OverlappingMatches(t *testing.T) {
+func TestSearchIndex_Search_Good_OverlappingMatches(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -982,13 +979,13 @@ func TestSearchIndex_Search_Good_OverlappingMatches(t *testing.T) {
 
 	// "search" should match: "searching", "search", "searches", "searchable"
 	results := idx.Search("search")
-	require.NotEmpty(t, results)
-	assert.Equal(t, "search-guide", results[0].Topic.ID)
+	RequireNotEmpty(t, results)
+	AssertEqual(t, "search-guide", results[0].Topic.ID)
 	// Score should be boosted since "search" appears in the title
-	assert.Greater(t, results[0].Score, 10.0)
+	AssertGreater(t, results[0].Score, 10.0)
 }
 
-func TestSearchIndex_Search_Good_ScoringBoundary(t *testing.T) {
+func TestSearchIndex_Search_Good_ScoringBoundary(t *T) {
 	idx := newSearchIndex()
 
 	// Topic A: exact title match
@@ -1013,14 +1010,14 @@ func TestSearchIndex_Search_Good_ScoringBoundary(t *testing.T) {
 	})
 
 	results := idx.Search("installation")
-	require.Len(t, results, 2)
+	AssertLen(t, results, 2)
 
 	// Title match gets +10 boost, so "exact-title" should rank first
-	assert.Equal(t, "exact-title", results[0].Topic.ID, "exact title match should rank above body-heavy match")
-	assert.Greater(t, results[0].Score, results[1].Score)
+	AssertEqual(t, "exact-title", results[0].Topic.ID, "exact title match should rank above body-heavy match")
+	AssertGreater(t, results[0].Score, results[1].Score)
 }
 
-func TestSearchIndex_Search_Good_TagMatching(t *testing.T) {
+func TestSearchIndex_Search_Good_TagMatching(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -1032,11 +1029,11 @@ func TestSearchIndex_Search_Good_TagMatching(t *testing.T) {
 
 	// Search for a tag that does not appear in title or content
 	results := idx.Search("devops")
-	require.NotEmpty(t, results)
-	assert.Equal(t, "tagged-topic", results[0].Topic.ID)
+	RequireNotEmpty(t, results)
+	AssertEqual(t, "tagged-topic", results[0].Topic.ID)
 }
 
-func TestSearchIndex_Search_Good_SectionTitleBoost(t *testing.T) {
+func TestSearchIndex_Search_Good_SectionTitleBoost(t *T) {
 	idx := newSearchIndex()
 
 	idx.Add(&Topic{
@@ -1056,65 +1053,69 @@ func TestSearchIndex_Search_Good_SectionTitleBoost(t *testing.T) {
 	})
 
 	results := idx.Search("deployment")
-	require.Len(t, results, 2)
+	AssertLen(t, results, 2)
 
 	// Section title match gives +5 boost (in addition to other scoring)
 	sectionResult := results[0]
-	assert.Equal(t, "section-match", sectionResult.Topic.ID)
+	AssertEqual(t, "section-match", sectionResult.Topic.ID)
 	if sectionResult.Section != nil {
-		assert.Equal(t, "deployment", sectionResult.Section.ID)
+		AssertEqual(t, "deployment", sectionResult.Section.ID)
 	}
 }
 
-func TestTokenize_Good_SpecialCases(t *testing.T) {
-	t.Run("only special characters", func(t *testing.T) {
+func TestTokenize_Good_SpecialCases(t *T) {
+	t.Run("only special characters", func(t *T) {
 		result := tokenize("!@#$%^&*()")
-		assert.Nil(t, result)
+		AssertNil(t, result)
 	})
 
-	t.Run("unicode tokens", func(t *testing.T) {
+	t.Run("unicode tokens", func(t *T) {
 		result := tokenize("日本語 テスト")
-		assert.NotEmpty(t, result, "CJK characters should tokenise as words")
+		AssertNotEmpty(t, result, "CJK characters should tokenise as words")
 	})
 
-	t.Run("mixed unicode and ascii", func(t *testing.T) {
+	t.Run("mixed unicode and ascii", func(t *T) {
 		result := tokenize("hello 世界 world")
-		assert.Contains(t, result, "hello")
-		assert.Contains(t, result, "world")
+		AssertContains(t, result, "hello")
+		AssertContains(t, result, "world")
 	})
 
-	t.Run("numbers only", func(t *testing.T) {
+	t.Run("numbers only", func(t *T) {
 		result := tokenize("12345 67890")
-		assert.Equal(t, []string{"12345", "67890"}, result)
+		AssertEqual(t, []string{"12345", "67890"}, result)
 	})
 
-	t.Run("hyphenated words split", func(t *testing.T) {
+	t.Run("hyphenated words split", func(t *T) {
 		result := tokenize("pre-commit")
-		assert.Equal(t, []string{"pre", "commit"}, result)
+		AssertEqual(t, []string{"pre", "commit"}, result)
 	})
 }
 
-func TestHighlight_Good_NoMatches(t *testing.T) {
+func TestHighlight_Good_NoMatches(t *T) {
 	result := highlight("no matches here", compileRegexes([]string{"xyz"}))
-	assert.Equal(t, "no matches here", result)
+	AssertEqual(t, "no matches here", result)
+	AssertContains(t, result, "matches")
+	AssertNotContains(t, result, "**")
 }
 
-func TestHighlight_Good_AdjacentMatches(t *testing.T) {
+func TestHighlight_Good_AdjacentMatches(t *T) {
 	// Two words right next to each other
 	result := highlight("foobar", compileRegexes([]string{"foo", "bar"}))
 	// "foo" and "bar" are adjacent, should be merged into one highlight
-	assert.Equal(t, "**foobar**", result)
+	AssertEqual(t, "**foobar**", result)
+	AssertContains(t, result, "foobar")
+	AssertNotContains(t, result, "****")
 }
 
-func TestExtractSnippet_Good_HeadingsSkipped(t *testing.T) {
+func TestExtractSnippet_Good_HeadingsSkipped(t *T) {
 	// When no regex is given, snippet should skip heading lines
 	content := "# Heading\n\nActual content here."
 	snippet := extractSnippet(content, nil)
-	assert.Contains(t, snippet, "Actual content here.")
-	assert.NotContains(t, snippet, "# Heading")
+	AssertContains(t, snippet, "Actual content here.")
+	AssertNotContains(t, snippet, "# Heading")
 }
 
-func TestSearchIndex_Search_Good_DuplicateTopicIDs(t *testing.T) {
+func TestSearchIndex_Search_Good_DuplicateTopicIDs(t *T) {
 	idx := newSearchIndex()
 
 	// Adding the same topic twice should not cause duplicate results
@@ -1127,10 +1128,10 @@ func TestSearchIndex_Search_Good_DuplicateTopicIDs(t *testing.T) {
 	idx.Add(topic)
 
 	results := idx.Search("unique")
-	assert.Len(t, results, 1)
+	AssertLen(t, results, 1)
 }
 
-func TestCatalog_Search_Good_Integration(t *testing.T) {
+func TestCatalog_Search_Good_Integration(t *T) {
 	// Test the full Catalog.Search path (integration through catalog -> index)
 	cat := &Catalog{
 		topics: make(map[string]*Topic),
@@ -1150,20 +1151,20 @@ func TestCatalog_Search_Good_Integration(t *testing.T) {
 		Tags:    []string{"release"},
 	})
 
-	t.Run("search via catalog", func(t *testing.T) {
+	t.Run("search via catalog", func(t *T) {
 		results := cat.Search("alpha")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "alpha", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "alpha", results[0].Topic.ID)
 	})
 
-	t.Run("search by tag via catalog", func(t *testing.T) {
+	t.Run("search by tag via catalog", func(t *T) {
 		results := cat.Search("experimental")
-		require.NotEmpty(t, results)
-		assert.Equal(t, "alpha", results[0].Topic.ID)
+		RequireNotEmpty(t, results)
+		AssertEqual(t, "alpha", results[0].Topic.ID)
 	})
 
-	t.Run("empty query via catalog", func(t *testing.T) {
+	t.Run("empty query via catalog", func(t *T) {
 		results := cat.Search("")
-		assert.Nil(t, results)
+		AssertNil(t, results)
 	})
 }
diff --git a/pkg/help/server.go b/pkg/help/server.go
index 6f19f62..380a542 100644
--- a/pkg/help/server.go
+++ b/pkg/help/server.go
@@ -116,7 +116,9 @@ func (s *Server) handleAPITopic(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
-		_ = json.NewEncoder(w).Encode(map[string]string{"error": "topic not found"})
+		if err := json.NewEncoder(w).Encode(map[string]string{"error": "topic not found"}); err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+		}
 		return
 	}
 
@@ -133,7 +135,9 @@ func (s *Server) handleAPISearch(w http.ResponseWriter, r *http.Request) {
 	if query == "" {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
-		_ = json.NewEncoder(w).Encode(map[string]string{"error": "missing query parameter 'q'"})
+		if err := json.NewEncoder(w).Encode(map[string]string{"error": "missing query parameter 'q'"}); err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+		}
 		return
 	}
 
diff --git a/pkg/help/server_test.go b/pkg/help/server_test.go
index 6f95ba3..635d082 100644
--- a/pkg/help/server_test.go
+++ b/pkg/help/server_test.go
@@ -2,17 +2,14 @@
 package help
 
 import (
+	. "dappco.re/go"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 // testServer creates a test catalog with topics and returns an httptest.Server.
-func testServer(t *testing.T) *httptest.Server {
+func testServer(t *T) *httptest.Server {
 	t.Helper()
 	c := &Catalog{
 		topics: make(map[string]*Topic),
@@ -40,158 +37,158 @@ func testServer(t *testing.T) *httptest.Server {
 	return httptest.NewServer(srv)
 }
 
-func TestServer_HandleIndex_Good(t *testing.T) {
+func TestServer_HandleIndex_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "text/html")
-	assert.Equal(t, "nosniff", resp.Header.Get("X-Content-Type-Options"))
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "text/html")
+	AssertEqual(t, "nosniff", resp.Header.Get("X-Content-Type-Options"))
 
 	var buf [64 * 1024]byte
 	n, _ := resp.Body.Read(buf[:])
 	body := string(buf[:n])
-	assert.Contains(t, body, "Getting Started")
-	assert.Contains(t, body, "Configuration")
+	AssertContains(t, body, "Getting Started")
+	AssertContains(t, body, "Configuration")
 }
 
-func TestServer_HandleTopic_Good(t *testing.T) {
+func TestServer_HandleTopic_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/topics/getting-started")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "text/html")
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "text/html")
 
 	var buf [64 * 1024]byte
 	n, _ := resp.Body.Read(buf[:])
 	body := string(buf[:n])
-	assert.Contains(t, body, "Getting Started")
-	assert.Contains(t, body, "<strong>guide</strong>")
+	AssertContains(t, body, "Getting Started")
+	AssertContains(t, body, "<strong>guide</strong>")
 }
 
-func TestServer_HandleTopic_Bad_NotFound(t *testing.T) {
+func TestServer_HandleTopic_Bad_NotFound(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/topics/nonexistent")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "text/html")
+	AssertEqual(t, http.StatusNotFound, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "text/html")
 }
 
-func TestServer_HandleSearch_Good(t *testing.T) {
+func TestServer_HandleSearch_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/search?q=install")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "text/html")
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "text/html")
 
 	var buf [64 * 1024]byte
 	n, _ := resp.Body.Read(buf[:])
 	body := string(buf[:n])
-	assert.Contains(t, body, "install")
+	AssertContains(t, body, "install")
 }
 
-func TestServer_HandleSearch_Bad_NoQuery(t *testing.T) {
+func TestServer_HandleSearch_Bad_NoQuery(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/search")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	AssertEqual(t, http.StatusBadRequest, resp.StatusCode)
 }
 
-func TestServer_HandleAPITopics_Good(t *testing.T) {
+func TestServer_HandleAPITopics_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/api/topics")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "application/json")
-	assert.Equal(t, "nosniff", resp.Header.Get("X-Content-Type-Options"))
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "application/json")
+	AssertEqual(t, "nosniff", resp.Header.Get("X-Content-Type-Options"))
 
 	var topics []Topic
-	require.NoError(t, json.NewDecoder(resp.Body).Decode(&topics))
-	assert.Len(t, topics, 2)
+	RequireNoError(t, json.NewDecoder(resp.Body).Decode(&topics))
+	AssertLen(t, topics, 2)
 }
 
-func TestServer_HandleAPITopic_Good(t *testing.T) {
+func TestServer_HandleAPITopic_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/api/topics/getting-started")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "application/json")
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "application/json")
 
 	var topic Topic
-	require.NoError(t, json.NewDecoder(resp.Body).Decode(&topic))
-	assert.Equal(t, "Getting Started", topic.Title)
-	assert.Equal(t, "getting-started", topic.ID)
+	RequireNoError(t, json.NewDecoder(resp.Body).Decode(&topic))
+	AssertEqual(t, "Getting Started", topic.Title)
+	AssertEqual(t, "getting-started", topic.ID)
 }
 
-func TestServer_HandleAPITopic_Bad_NotFound(t *testing.T) {
+func TestServer_HandleAPITopic_Bad_NotFound(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/api/topics/nonexistent")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "application/json")
+	AssertEqual(t, http.StatusNotFound, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "application/json")
 }
 
-func TestServer_HandleAPISearch_Good(t *testing.T) {
+func TestServer_HandleAPISearch_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/api/search?q=config")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "application/json")
+	AssertEqual(t, http.StatusOK, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "application/json")
 
 	var results []SearchResult
-	require.NoError(t, json.NewDecoder(resp.Body).Decode(&results))
-	assert.NotEmpty(t, results)
+	RequireNoError(t, json.NewDecoder(resp.Body).Decode(&results))
+	AssertNotEmpty(t, results)
 }
 
-func TestServer_HandleAPISearch_Bad_NoQuery(t *testing.T) {
+func TestServer_HandleAPISearch_Bad_NoQuery(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
 	resp, err := http.Get(ts.URL + "/api/search")
-	require.NoError(t, err)
+	RequireNoError(t, err)
 	defer resp.Body.Close()
 
-	assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
-	assert.Contains(t, resp.Header.Get("Content-Type"), "application/json")
+	AssertEqual(t, http.StatusBadRequest, resp.StatusCode)
+	AssertContains(t, resp.Header.Get("Content-Type"), "application/json")
 }
 
-func TestServer_ContentTypeHeaders_Good(t *testing.T) {
+func TestServer_ContentTypeHeaders_Good(t *T) {
 	ts := testServer(t)
 	defer ts.Close()
 
@@ -209,23 +206,23 @@ func TestServer_ContentTypeHeaders_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			resp, err := http.Get(ts.URL + tt.path)
-			require.NoError(t, err)
+			RequireNoError(t, err)
 			defer resp.Body.Close()
 
-			assert.Contains(t, resp.Header.Get("Content-Type"), tt.contentType,
+			AssertContains(t, resp.Header.Get("Content-Type"), tt.contentType,
 				"Content-Type for %s should contain %s", tt.path, tt.contentType)
 		})
 	}
 }
 
-func TestNewServer_Good(t *testing.T) {
+func TestNewServer_Good(t *T) {
 	c := DefaultCatalog()
 	srv := NewServer(c, ":8080")
 
-	assert.NotNil(t, srv)
-	assert.Equal(t, ":8080", srv.addr)
-	assert.NotNil(t, srv.mux)
-	assert.Equal(t, c, srv.catalog)
+	AssertNotNil(t, srv)
+	AssertEqual(t, ":8080", srv.addr)
+	AssertNotNil(t, srv.mux)
+	AssertEqual(t, c, srv.catalog)
 }
diff --git a/pkg/help/stemmer_test.go b/pkg/help/stemmer_test.go
index 3b774b8..adfde18 100644
--- a/pkg/help/stemmer_test.go
+++ b/pkg/help/stemmer_test.go
@@ -2,17 +2,14 @@
 package help
 
 import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	. "dappco.re/go"
 )
 
 // ---------------------------------------------------------------------------
 // stem() unit tests
 // ---------------------------------------------------------------------------
 
-func TestStem_Good(t *testing.T) {
+func TestStem_Good(t *T) {
 	tests := []struct {
 		name     string
 		input    string
@@ -46,14 +43,14 @@ func TestStem_Good(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.name, func(t *T) {
 			result := stem(tt.input)
-			assert.Equal(t, tt.expected, result)
+			AssertEqual(t, tt.expected, result)
 		})
 	}
 }
 
-func TestStem_ShortWordsUnchanged(t *testing.T) {
+func TestStem_ShortWordsUnchanged(t *T) {
 	tests := []struct {
 		name  string
 		input string
@@ -65,25 +62,27 @@ func TestStem_ShortWordsUnchanged(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.input, stem(tt.input), "words under 4 chars should be unchanged")
+		t.Run(tt.name, func(t *T) {
+			AssertEqual(t, tt.input, stem(tt.input), "words under 4 chars should be unchanged")
 		})
 	}
 }
 
-func TestStem_GuardMinLength(t *testing.T) {
+func TestStem_GuardMinLength(t *T) {
 	// The stem function must never reduce a word below 2 characters.
 	// "ed" removal from a 4-char word like "abed" would leave "ab" (ok).
 	// We test that it doesn't return a single-char result.
 	result := stem("abed")
-	assert.GreaterOrEqual(t, len(result), 2, "result must be at least 2 chars")
+	AssertGreaterOrEqual(t, len(result), 2, "result must be at least 2 chars")
+	AssertNotEmpty(t, result)
+	AssertNotEqual(t, "a", result)
 }
 
 // ---------------------------------------------------------------------------
 // Search integration tests — stemming recall
 // ---------------------------------------------------------------------------
 
-func TestSearch_StemRunningMatchesRun(t *testing.T) {
+func TestSearch_StemRunningMatchesRun(t *T) {
 	idx := newSearchIndex()
 	idx.Add(&Topic{
 		ID:      "topic-run",
@@ -92,11 +91,11 @@ func TestSearch_StemRunningMatchesRun(t *testing.T) {
 	})
 
 	results := idx.Search("running")
-	require.NotEmpty(t, results, "searching 'running' should match topic containing 'run'")
-	assert.Equal(t, "topic-run", results[0].Topic.ID)
+	RequireNotEmpty(t, results, "searching 'running' should match topic containing 'run'")
+	AssertEqual(t, "topic-run", results[0].Topic.ID)
 }
 
-func TestSearch_StemConfigurationsMatchesConfigure(t *testing.T) {
+func TestSearch_StemConfigurationsMatchesConfigure(t *T) {
 	idx := newSearchIndex()
 	idx.Add(&Topic{
 		ID:      "topic-configure",
@@ -105,11 +104,11 @@ func TestSearch_StemConfigurationsMatchesConfigure(t *testing.T) {
 	})
 
 	results := idx.Search("configurations")
-	require.NotEmpty(t, results, "searching 'configurations' should match topic containing 'configure'")
-	assert.Equal(t, "topic-configure", results[0].Topic.ID)
+	RequireNotEmpty(t, results, "searching 'configurations' should match topic containing 'configure'")
+	AssertEqual(t, "topic-configure", results[0].Topic.ID)
 }
 
-func TestSearch_StemPluralServersMatchesServer(t *testing.T) {
+func TestSearch_StemPluralServersMatchesServer(t *T) {
 	idx := newSearchIndex()
 	idx.Add(&Topic{
 		ID:      "topic-server",
@@ -118,11 +117,11 @@ func TestSearch_StemPluralServersMatchesServer(t *testing.T) {
 	})
 
 	results := idx.Search("servers")
-	require.NotEmpty(t, results, "searching 'servers' should match topic containing 'server'")
-	assert.Equal(t, "topic-server", results[0].Topic.ID)
+	RequireNotEmpty(t, results, "searching 'servers' should match topic containing 'server'")
+	AssertEqual(t, "topic-server", results[0].Topic.ID)
 }
 
-func TestSearch_StemScoringLowerThanExact(t *testing.T) {
+func TestSearch_StemScoringLowerThanExact(t *T) {
 	idx := newSearchIndex()
 	idx.Add(&Topic{
 		ID:      "exact-match",
@@ -136,7 +135,7 @@ func TestSearch_StemScoringLowerThanExact(t *testing.T) {
 	})
 
 	results := idx.Search("running")
-	require.Len(t, results, 2, "should match both topics")
+	AssertLen(t, results, 2, "should match both topics")
 
 	// The topic containing the exact word "running" should score higher
 	// than the one matched only via the stem "run" (all else being equal,
@@ -150,11 +149,11 @@ func TestSearch_StemScoringLowerThanExact(t *testing.T) {
 			stemScore = r.Score
 		}
 	}
-	assert.Greater(t, exactScore, stemScore,
+	AssertGreater(t, exactScore, stemScore,
 		"exact word match should score higher than stem-only match")
 }
 
-func TestSearch_ExistingExactMatchUnaffected(t *testing.T) {
+func TestSearch_ExistingExactMatchUnaffected(t *T) {
 	// Ensure stemming doesn't break exact-match searches.
 	idx := newSearchIndex()
 	idx.Add(&Topic{
@@ -164,29 +163,29 @@ func TestSearch_ExistingExactMatchUnaffected(t *testing.T) {
 	})
 
 	results := idx.Search("deploy")
-	require.NotEmpty(t, results)
-	assert.Equal(t, "topic-deploy", results[0].Topic.ID)
+	RequireNotEmpty(t, results)
+	AssertEqual(t, "topic-deploy", results[0].Topic.ID)
 }
 
-func TestTokenize_IncludesStemmedVariants(t *testing.T) {
+func TestTokenize_IncludesStemmedVariants(t *T) {
 	words := tokenize("running configurations servers")
 
 	// Should contain originals
-	assert.Contains(t, words, "running")
-	assert.Contains(t, words, "configurations")
-	assert.Contains(t, words, "servers")
+	AssertContains(t, words, "running")
+	AssertContains(t, words, "configurations")
+	AssertContains(t, words, "servers")
 
 	// Should also contain stems
-	assert.Contains(t, words, "runn")        // stem of running (ing removed)
-	assert.Contains(t, words, "configurate") // stem of configurations (s->configuration->ation->ate)
-	assert.Contains(t, words, "server")      // stem of servers (s removed)
+	AssertContains(t, words, "runn")        // stem of running (ing removed)
+	AssertContains(t, words, "configurate") // stem of configurations (s->configuration->ation->ate)
+	AssertContains(t, words, "server")      // stem of servers (s removed)
 }
 
 // ---------------------------------------------------------------------------
 // Benchmark
 // ---------------------------------------------------------------------------
 
-func BenchmarkStem(b *testing.B) {
+func BenchmarkStem(b *B) {
 	words := []string{
 		"running", "configurations", "servers", "deployment", "testing",
 		"addresses", "agreed", "configured", "operational", "cheerfulness",
diff --git a/pkg/help/templates_test.go b/pkg/help/templates_test.go
index f588a58..609c31d 100644
--- a/pkg/help/templates_test.go
+++ b/pkg/help/templates_test.go
@@ -2,13 +2,10 @@
 package help
 
 import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	. "dappco.re/go"
 )
 
-func TestGroupTopicsByTag_Good(t *testing.T) {
+func TestGroupTopicsByTag_Good(t *T) {
 	topics := []*Topic{
 		{ID: "a", Title: "Alpha", Tags: []string{"setup"}, Order: 2},
 		{ID: "b", Title: "Beta", Tags: []string{"setup"}, Order: 1},
@@ -17,16 +14,16 @@ func TestGroupTopicsByTag_Good(t *testing.T) {
 	}
 
 	groups := groupTopicsByTag(topics)
-	require.Len(t, groups, 3)
+	AssertLen(t, groups, 3)
 
 	// Groups should be sorted alphabetically by tag
-	assert.Equal(t, "advanced", groups[0].Tag)
-	assert.Equal(t, "other", groups[1].Tag)
-	assert.Equal(t, "setup", groups[2].Tag)
+	AssertEqual(t, "advanced", groups[0].Tag)
+	AssertEqual(t, "other", groups[1].Tag)
+	AssertEqual(t, "setup", groups[2].Tag)
 
 	// Within "setup", topics should be sorted by Order then Title
 	setupGroup := groups[2]
-	require.Len(t, setupGroup.Topics, 2)
-	assert.Equal(t, "Beta", setupGroup.Topics[0].Title)  // Order 1
-	assert.Equal(t, "Alpha", setupGroup.Topics[1].Title) // Order 2
+	AssertLen(t, setupGroup.Topics, 2)
+	AssertEqual(t, "Beta", setupGroup.Topics[0].Title)  // Order 1
+	AssertEqual(t, "Alpha", setupGroup.Topics[1].Title) // Order 2
 }