test(bench): white-box benches for unexported helpers + Println/HTTPListenAndServe

safeName (Action/Task), Fs.path, assertFail/assertMsg (via a capturing TB stub);
Println redirected to /dev/null; HTTPListenAndServe on its error path.

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

api_bench_test.go

@@ -308,6 +308,12 @@ func BenchmarkCore_RemoteAction(b *B) {
 	}
 }
 
-// HTTPListenAndServe + RemoteAction are not benched — they bind a real
-// socket / make a real outbound HTTP call. A unit-bench cannot do that
-// deterministically. They are exercised end-to-end in api_test.go.
+// HTTPListenAndServe is benched on its error path: an invalid address
+// fails the bind immediately and returns the error Result, with no real
+// socket. The success path blocks serving, so it can't be unit-benched.
+func BenchmarkHTTPListenAndServe(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		apiSinkResult = HTTPListenAndServe("127.0.0.1:-1", nil)
+	}
+}

format_bench_test.go

@@ -11,6 +11,7 @@ package core_test
 
 import (
 	"bytes"
+	"os"
 
 	. "dappco.re/go"
 )
@@ -89,3 +90,22 @@ func BenchmarkFormat_Errorf_Wrap(b *B) {
 		formatSinkErr = Errorf("connect %s: %w", "homelab", cause)
 	}
 }
+
+// Println writes to os.Stdout; redirect to /dev/null so the bench measures
+// the formatting + write cost, not terminal scroll.
+func BenchmarkPrintln(b *B) {
+	devnull, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
+	if err != nil {
+		b.Skip("no /dev/null")
+	}
+	old := os.Stdout
+	os.Stdout = devnull
+	defer func() {
+		os.Stdout = old
+		devnull.Close()
+	}()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		Println("agent ready", 42)
+	}
+}

whitebox_bench_test.go

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// White-box benchmarks for unexported helpers a black-box (core_test)
+// bench can't reach: action/task name sanitisation, sandbox path
+// resolution, and the assertion failure/message formatters (driven
+// through a capturing TB stub so the bench exercises the real formatting
+// path without actually failing).
+//
+// Run:    go test -bench='Benchmark(Action_safeName|Task_safeName|Fs_path|AssertFail|AssertMsg)' -benchmem -run='^$' .
+
+package core
+
+// assertBenchStub embeds *B — inheriting the unexported method that makes
+// it a testing.TB — and swallows Error/Fatal so assertFail runs its real
+// formatting path without failing the benchmark.
+type assertBenchStub struct{ *B }
+
+func (assertBenchStub) Error(args ...any) {}
+func (assertBenchStub) Fatal(args ...any) {}
+
+var whiteboxSink string
+
+func BenchmarkAction_safeName(b *B) {
+	a := &Action{Name: "agentic.dispatch"}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		whiteboxSink = a.safeName()
+	}
+}
+
+func BenchmarkTask_safeName(b *B) {
+	t := &Task{Name: "deploy.homelab"}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		whiteboxSink = t.safeName()
+	}
+}
+
+func BenchmarkFs_path(b *B) {
+	m := (&Fs{}).New("/tmp")
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		whiteboxSink = m.path("workspace/agent/readme.md")
+	}
+}
+
+func BenchmarkAssertFail(b *B) {
+	stub := assertBenchStub{b}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		assertFail(stub, false, "Bench", nil, "want", 1, "got", 2)
+	}
+}
+
+func BenchmarkAssertMsg(b *B) {
+	msg := []string{"context line", "detail line"}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		whiteboxSink = assertMsg(msg)
+	}
+}