fix(sdk-go): log Wrap record failures instead of panicking

When the wrapped function succeeds but outbox recording fails,
return the result and log the infrastructure error. Panic paths
still attach recording failures before re-raising.

Signed-off-by: Nathan Gillett <nathan@intentproof.io>

Author: Nathan Gillett

intentproof/instrumentation.go

@@ -2,11 +2,16 @@ package intentproof
 
 import (
 	"fmt"
+	"log"
 	"time"
 
 	"github.com/oklog/ulid/v2"
 )
 
+var logExecutionRecordFailure = func(err error) {
+	log.Printf("[intentproof] execution record failed: %v", err)
+}
+
 // RunWithCorrelationID runs fn with correlation_id set for nested wrap() calls.
 func RunWithCorrelationID(correlationID string, fn func()) {
 	runWithCorrelationID(correlationID, fn)
@@ -95,7 +100,9 @@ func recordExecution(
 }
 
 // Wrap instruments fn to emit a signed ExecutionEvent.v1 on each call.
-// Panics from fn are re-raised after recording an error event.
+// Panics from fn are re-raised after recording an error event. When fn
+// returns normally but recording fails, the result is still returned and
+// the failure is logged; use WrapFunc to surface recording errors.
 func Wrap[T, R any](intent, action string, fn func(T) R) func(T) R {
 	return func(arg T) (result R) {
 		t0 := time.Now().UnixMilli()
@@ -130,7 +137,7 @@ func Wrap[T, R any](intent, action string, fn func(T) R) func(T) R {
 			if didPanic {
 				panic(fmt.Errorf("%v: %w", panicVal, recErr))
 			}
-			panic(recErr)
+			logExecutionRecordFailure(recErr)
 		}
 		if didPanic {
 			panic(panicVal)

intentproof/instrumentation_internal_test.go

@@ -0,0 +1,45 @@
+package intentproof
+
+import (
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+)
+
+func TestWrapLogsRecordFailureOnSuccessPath(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "outbox.db")
+	dataDir := filepath.Join(dir, "data")
+	if err := Configure(ConfigureOptions{
+		DBPath:   dbPath,
+		DataDir:  dataDir,
+		TenantID: "tnt_log_rec",
+	}); err != nil {
+		t.Fatal(err)
+	}
+	ob, err := GetOutbox()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ob.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	var logged atomic.Bool
+	prev := logExecutionRecordFailure
+	logExecutionRecordFailure = func(err error) {
+		logged.Store(true)
+		if err == nil {
+			t.Fatal("expected record error")
+		}
+	}
+	defer func() { logExecutionRecordFailure = prev }()
+
+	fn := Wrap("Test", "test.action", func(x int) int { return x + 1 })
+	if got := fn(2); got != 3 {
+		t.Fatalf("result: got %d want 3", got)
+	}
+	if !logged.Load() {
+		t.Fatal("expected record failure to be logged")
+	}
+}

intentproof/sdk_test.go

@@ -158,7 +158,7 @@ func TestConcurrentWrapPreservesChainPositions(t *testing.T) {
 	}
 }
 
-func TestWrapRecordFailureOnSuccessPathDoesNotMisclassify(t *testing.T) {
+func TestWrapRecordFailureOnSuccessPathReturnsResult(t *testing.T) {
 	dbPath, dataDir := testDirs(t)
 	configureTest(t, dbPath, dataDir, "tnt_a")
 	ob, err := intentproof.GetOutbox()
@@ -170,17 +170,17 @@ func TestWrapRecordFailureOnSuccessPathDoesNotMisclassify(t *testing.T) {
 	}
 
 	fn := intentproof.Wrap("Test", "test.action", func(x int) int { return x * 2 })
-	panicked := false
+	var got int
 	func() {
 		defer func() {
 			if recover() != nil {
-				panicked = true
+				t.Fatal("unexpected panic on success-path record failure")
 			}
 		}()
-		intentproof.RunWithCorrelationID("corr-rec-fail", func() { fn(3) })
+		intentproof.RunWithCorrelationID("corr-rec-fail", func() { got = fn(3) })
 	}()
-	if !panicked {
-		t.Fatal("expected panic from record failure")
+	if got != 6 {
+		t.Fatalf("result: got %d want 6", got)
 	}
 
 	ob2, err := intentproof.OpenOutbox(dbPath)