Merge fix/core-dev-build — fixed latest core dev + dedup primitives

Brings github core dev (106 commits past v0.10.4) with the incomplete
error->Result migration finished (see fix commit), merged with the
dedup primitives (Pool/Coalesce/FirstPositive/SliceEqual/FirstNonBlank/
MapString/Result.Err). Full suite green.

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

Author: Snider

action_bench_test.go

@@ -207,3 +207,21 @@ func BenchmarkAction_Tasks(b *B) {
 		actionSinkStrings = c.Tasks()
 	}
 }
+
+func BenchmarkCore_PerformAsync(b *B) {
+	c := New()
+	c.Action("bench.async", noopActionHandler())
+	opts := NewOptions()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		actionSinkResult = c.PerformAsync("bench.async", opts)
+	}
+}
+
+func BenchmarkCore_Progress(b *B) {
+	c := New()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		c.Progress("bench.task", 0.5, "halfway", "bench.async")
+	}
+}

action_example_test.go

@@ -205,6 +205,33 @@ func ExampleCore_PerformAsync() {
 
 // ExampleCore_Progress reports task progress through `Core.Progress` for background task
 // progress. Asynchronous work reports progress through Core task helpers.
+// ExampleAction_Enable re-enables a disabled action through `Action.Enable`.
+func ExampleAction_Enable() {
+	c := New()
+	a := c.Action("deploy", func(_ Context, _ Options) Result { return Result{OK: true} })
+	a.Disable()
+	a.Enable()
+	Println(a.Enabled())
+	// Output: true
+}
+
+// ExampleAction_Disable soft-disables an action through `Action.Disable`.
+func ExampleAction_Disable() {
+	c := New()
+	a := c.Action("deploy", func(_ Context, _ Options) Result { return Result{OK: true} })
+	a.Disable()
+	Println(a.Enabled())
+	// Output: false
+}
+
+// ExampleAction_Enabled reports whether an action is active through `Action.Enabled`.
+func ExampleAction_Enabled() {
+	c := New()
+	a := c.Action("deploy", func(_ Context, _ Options) Result { return Result{OK: true} })
+	Println(a.Enabled())
+	// Output: true
+}
+
 func ExampleCore_Progress() {
 	c := New()
 	var progress float64

action_test.go

@@ -633,9 +633,10 @@ func TestAction_Core_Progress_Good(t *T) {
 func TestAction_Core_Progress_Bad(t *T) {
 	c := New()
 
-	c.Progress("task-absent", -1, "refused", "agent.dispatch")
-
-	AssertTrue(t, true)
+	// Reporting progress for an unknown task is a safe no-op, not a panic.
+	AssertNotPanics(t, func() {
+		c.Progress("task-absent", -1, "refused", "agent.dispatch")
+	})
 }
 
 func TestAction_Core_Progress_Ugly(t *T) {

alloc_gate_test.go

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// Allocation regression gates. Unlike a Benchmark (which only prints a
+// number nobody compares), each case here asserts a hard ceiling on
+// allocations-per-call via testing.AllocsPerRun — so the suite FAILS if a
+// hot primitive starts allocating where it didn't before. ns/op is
+// deliberately not gated (machine-dependent); allocs are stable.
+//
+// Ceilings are the measured floor as of this commit:
+//   0 — pure / zero-copy primitive (no heap touch)
+//   1 — one unavoidable alloc: Result{Value:<non-pointer>} boxes the value
+//       into `any` (string/int → 1 alloc; pointer values box for free)
+//
+// Tightening a ceiling that's been beaten is welcome; raising one is a
+// regression that needs justifying in review.
+//
+// Run:    go test -run 'TestAllocs_' .
+
+package core_test
+
+import (
+	"testing"
+
+	. "dappco.re/go"
+)
+
+// gate sinks — keep the measured call from being elided as dead code.
+var (
+	gateInt    int
+	gateBool   bool
+	gateStr    string
+	gateBytes  []byte
+	gateResult Result
+	gateAny    any
+	gateDiags  []LSPDiagnostic
+)
+
+func TestAllocs_HotPrimitives(t *T) {
+	ptr := &struct{ n int }{}
+	bs := []byte("homelab")
+	var ai32 AtomicInt32
+	var ab AtomicBool
+	var au64 AtomicUint64
+	cases := []struct {
+		name    string
+		ceiling int
+		fn      func()
+	}{
+		// math / ordering — pure, must stay 0
+		{"Compare", 0, func() { gateInt = Compare(3, 7) }},
+		{"Min", 0, func() { gateInt = Min(3, 7) }},
+		{"Max", 0, func() { gateInt = Max(3, 7) }},
+		{"Abs", 0, func() { gateInt = Abs(-42) }},
+		{"Clamp", 0, func() { gateInt = Clamp(15, 0, 10) }},
+		{"Sign", 0, func() { gateInt = Sign(-3) }},
+
+		// string predicates / index — pure, must stay 0
+		{"Contains", 0, func() { gateBool = Contains("agent ready", "ready") }},
+		{"HasPrefix", 0, func() { gateBool = HasPrefix("agent.go", "agent") }},
+		{"HasSuffix", 0, func() { gateBool = HasSuffix("agent.go", ".go") }},
+		{"EqualFold", 0, func() { gateBool = EqualFold("Bearer", "bearer") }},
+		{"Index", 0, func() { gateInt = Index("agent", "e") }},
+		{"Count", 0, func() { gateInt = Count("banana", "a") }},
+		{"Trim", 0, func() { gateStr = Trim("  x  ") }},
+
+		// slice search — pure, must stay 0
+		{"SliceContains", 0, func() { gateBool = SliceContains([]int{1, 2, 3}, 2) }},
+		{"SliceIndex", 0, func() { gateInt = SliceIndex([]int{1, 2, 3}, 2) }},
+
+		// unsafe zero-copy conversions — must stay 0
+		{"AsBytes", 0, func() { gateBytes = AsBytes("homelab") }},
+		{"AsString", 0, func() { gateStr = AsString(bs) }},
+
+		// Result constructors — pointer value boxes for free (0); a
+		// non-pointer value pays the one inherent Result-boxing alloc.
+		{"Ok_Pointer", 0, func() { gateResult = Ok(ptr) }},
+		{"Fail", 0, func() { gateResult = Fail(AnError) }},
+		{"Ok_String", 1, func() { gateResult = Ok("ready") }},
+		{"ResultOf_String", 1, func() { gateResult = ResultOf("ready", nil) }},
+
+		// Result accessors — pure reads, must stay 0
+		{"Result_Or", 0, func() { gateAny = (Result{OK: false}).Or("fallback") }},
+
+		// atomics — lock-free, must stay 0
+		{"AtomicInt32_Load", 0, func() { gateInt = int(ai32.Load()) }},
+		{"AtomicInt32_Store", 0, func() { ai32.Store(7) }},
+		{"AtomicInt32_Add", 0, func() { gateInt = int(ai32.Add(1)) }},
+		{"AtomicBool_Load", 0, func() { gateBool = ab.Load() }},
+		{"AtomicBool_Store", 0, func() { ab.Store(true) }},
+		{"AtomicUint64_Add", 0, func() { gateInt = int(au64.Add(1)) }},
+
+		// more math — pure, must stay 0
+		{"Pow", 0, func() { gateInt = int(Pow(2, 8)) }},
+		{"Floor", 0, func() { gateInt = int(Floor(3.7)) }},
+		{"Ceil", 0, func() { gateInt = int(Ceil(3.1)) }},
+		{"Round", 0, func() { gateInt = int(Round(3.5)) }},
+
+		// slice — Clone copies (1 alloc for the backing array); Reverse is in-place (0)
+		{"SliceClone", 1, func() { gateBytes = SliceClone(bs) }},
+	}
+	for _, c := range cases {
+		avg := int(testing.AllocsPerRun(1000, c.fn))
+		AssertLessOrEqual(t, avg, c.ceiling, c.name)
+	}
+}
+
+// TestAllocs_LSPComputeDiagnostics locks the regex-hoist win (c1cf230):
+// with per-call regexp.Compile it allocated ~186/call; compiling the
+// naming-diagnostic patterns once dropped it to ~47. A regression to
+// per-call compilation jumps back over 100, so the ceiling catches it.
+func TestAllocs_LSPComputeDiagnostics(t *T) {
+	uri := "file:///agent/worker.go"
+	content := []byte("package worker\n\nfunc process(in string) (string, error) {\n\treturn in, nil\n}\n")
+	LSPComputeDiagnostics(uri, content) // warm the per-dir cache → measure steady state
+	avg := int(testing.AllocsPerRun(200, func() {
+		gateDiags = LSPComputeDiagnostics(uri, content)
+	}))
+	AssertLessOrEqual(t, avg, 70, "LSPComputeDiagnostics")
+}
+
+var gateStrSlice []string
+
+// TestAllocs_FilterArgs locks the pre-size win (1f59e31): was an unpresized
+// 'var clean []string' + append (geometric regrow), now the single presized
+// result allocation. (Typed sink — assigning to `any` would box and add a
+// spurious alloc.)
+func TestAllocs_FilterArgs(t *T) {
+	args := []string{"deploy", "--target", "homelab", "-v"}
+	fa := int(testing.AllocsPerRun(1000, func() { gateStrSlice = FilterArgs(args) }))
+	AssertLessOrEqual(t, fa, 1, "FilterArgs")
+}

api.go

@@ -356,15 +356,21 @@ func HTTPStripPrefix(prefix string, h Handler) Handler {
 	return http.StripPrefix(prefix, h)
 }
 
-// HTTPListenAndServe runs an HTTPServer on the given address with the
-// given handler. Returns ErrHTTPServerClosed after graceful shutdown,
-// other errors otherwise.
-//
-//	if err := core.HTTPListenAndServe(":8080", mux); !core.Is(err, core.ErrHTTPServerClosed) {
-//	    core.Error("listen", "err", err)
+// HTTPListenAndServe runs an HTTPServer on the given address with the given
+// handler, returning a Result. ListenAndServe only returns on error, so a
+// non-OK Result is the normal outcome — Value carries ErrHTTPServerClosed after
+// a graceful shutdown, other errors otherwise.
+//
+//	if r := core.HTTPListenAndServe(":8080", mux); !r.OK {
+//	    if err, _ := r.Value.(error); !core.Is(err, core.ErrHTTPServerClosed) {
+//	        core.Error("listen", "err", err)
+//	    }
 //	}
-func HTTPListenAndServe(addr string, handler Handler) error {
-	return http.ListenAndServe(addr, handler)
+func HTTPListenAndServe(addr string, handler Handler) Result {
+	if err := http.ListenAndServe(addr, handler); err != nil {
+		return Result{Value: err, OK: false}
+	}
+	return Result{OK: true}
 }
 
 // HTTPFileServer returns a Handler that serves HTTP requests with the

api_bench_test.go

@@ -260,6 +260,60 @@ func BenchmarkNewHTTPTestTLSServer(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.
+// --- remote-endpoint surface (Drive + protocol resolution) ---
+//
+// A mock protocol factory stands in for a live transport so these bench
+// the resolve + scheme-extraction + call dispatch path, not the network.
+// HTTPListenAndServe is omitted — it blocks serving until shut down.
+
+var apiSinkResult Result
+
+func apiRemoteFixture() *Core {
+	c := New()
+	c.API().RegisterProtocol("http", mockFactory("pong"))
+	c.Drive().New(NewOptions(
+		Option{Key: "name", Value: "charon"},
+		Option{Key: "transport", Value: "http://127.0.0.1:9101/mcp"},
+	))
+	return c
+}
+
+func BenchmarkAPI_Stream(b *B) {
+	c := apiRemoteFixture()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		r := c.API().Stream("charon")
+		if r.OK {
+			r.Value.(Stream).Close()
+		}
+	}
+}
+
+func BenchmarkAPI_Call(b *B) {
+	c := apiRemoteFixture()
+	opts := NewOptions()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		apiSinkResult = c.API().Call("charon", "agentic.status", opts)
+	}
+}
+
+func BenchmarkCore_RemoteAction(b *B) {
+	c := apiRemoteFixture()
+	ctx := Background()
+	opts := NewOptions()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		apiSinkResult = c.RemoteAction("charon:agentic.status", ctx, opts)
+	}
+}
+
+// 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 = Result{Value: HTTPListenAndServe("127.0.0.1:-1", nil)}
+	}
+}

api_example_test.go

@@ -412,6 +412,12 @@ func ExampleHTTPFS() {
 // ExampleHTTPError writes a plain-text error body with the given status
 // code. The handler exits after this call; the Recorder captures the
 // response for assertion in tests.
+// ExampleCore_API returns the HTTP API subsystem through `Core.API`.
+func ExampleCore_API() {
+	Println(New().API() != nil)
+	// Output: true
+}
+
 func ExampleHTTPError() {
 	rec := NewHTTPTestRecorder()
 	HTTPError(rec, "missing field", StatusBadRequest)