Make hook audit writes async and non-blocking

Author: drpedapati

pkg/agent/loop_test.go

@@ -672,16 +672,23 @@ func TestAgentLoop_WritesHookAuditEvents(t *testing.T) {
 	}
 
 	auditPath := filepath.Join(tmpDir, "hooks", "hook-events.jsonl")
-	data, err := os.ReadFile(auditPath)
-	if err != nil {
-		t.Fatalf("read hook audit file: %v", err)
-	}
-	body := string(data)
-	if !strings.Contains(body, "\"event\":\"before_turn\"") {
-		t.Fatalf("expected before_turn event in audit file")
-	}
-	if !strings.Contains(body, "\"event\":\"after_turn\"") {
-		t.Fatalf("expected after_turn event in audit file")
+	deadline := time.Now().Add(2 * time.Second)
+	var body string
+	for {
+		data, readErr := os.ReadFile(auditPath)
+		if readErr == nil {
+			body = string(data)
+			if strings.Contains(body, "\"event\":\"before_turn\"") && strings.Contains(body, "\"event\":\"after_turn\"") {
+				break
+			}
+		}
+		if time.Now().After(deadline) {
+			if readErr != nil {
+				t.Fatalf("read hook audit file after wait: %v", readErr)
+			}
+			t.Fatalf("expected before_turn and after_turn events in audit file, got: %s", body)
+		}
+		time.Sleep(10 * time.Millisecond)
 	}
 }
 

pkg/hooks/audit_jsonl.go

@@ -5,13 +5,17 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"sync"
+)
+
+const (
+	// Buffer audit writes so hook dispatch never blocks on slow filesystems.
+	auditQueueSize = 256
 )
 
 // JSONLAuditSink appends hook entries as JSONL.
 type JSONLAuditSink struct {
-	mu   sync.Mutex
-	path string
+	path  string
+	queue chan []byte
 }
 
 func NewJSONLAuditSink(workspace string) (*JSONLAuditSink, error) {
@@ -23,28 +27,57 @@ func NewJSONLAuditSinkAt(path string) (*JSONLAuditSink, error) {
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return nil, fmt.Errorf("create hooks audit dir: %w", err)
 	}
-	return &JSONLAuditSink{path: path}, nil
+	sink := &JSONLAuditSink{
+		path:  path,
+		queue: make(chan []byte, auditQueueSize),
+	}
+	go sink.writeLoop()
+	return sink, nil
 }
 
 func (s *JSONLAuditSink) Path() string {
 	return s.path
 }
 
 func (s *JSONLAuditSink) Write(entry AuditEntry) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	f, err := os.OpenFile(s.path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
+	b, err := json.Marshal(entry)
 	if err != nil {
 		return err
 	}
-	defer f.Close()
 
-	b, err := json.Marshal(entry)
+	line := append(b, '\n')
+	select {
+	case s.queue <- line:
+		return nil
+	default:
+	}
+
+	// Queue full: drop oldest pending line so current hook event can proceed.
+	select {
+	case <-s.queue:
+	default:
+	}
+	select {
+	case s.queue <- line:
+	default:
+	}
+	return nil
+}
+
+func (s *JSONLAuditSink) writeLoop() {
+	for line := range s.queue {
+		_ = s.appendLine(line)
+	}
+}
+
+func (s *JSONLAuditSink) appendLine(line []byte) error {
+	f, err := os.OpenFile(s.path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
 	if err != nil {
 		return err
 	}
-	if _, err := f.Write(append(b, '\n')); err != nil {
+	defer f.Close()
+
+	if _, err := f.Write(line); err != nil {
 		return err
 	}
 	return nil

pkg/hooks/audit_jsonl_test.go

@@ -18,11 +18,20 @@ func TestJSONLAuditSinkWrite(t *testing.T) {
 	if err := sink.Write(entry); err != nil {
 		t.Fatalf("Write: %v", err)
 	}
-	data, err := os.ReadFile(filepath.Join(ws, "hooks", "hook-events.jsonl"))
-	if err != nil {
-		t.Fatalf("read audit file: %v", err)
-	}
-	if !strings.Contains(string(data), "\"turn_id\":\"turn-1\"") {
-		t.Fatalf("audit content missing turn_id: %s", string(data))
+
+	auditPath := filepath.Join(ws, "hooks", "hook-events.jsonl")
+	deadline := time.Now().Add(2 * time.Second)
+	for {
+		data, err := os.ReadFile(auditPath)
+		if err == nil && strings.Contains(string(data), "\"turn_id\":\"turn-1\"") {
+			return
+		}
+		if time.Now().After(deadline) {
+			if err != nil {
+				t.Fatalf("read audit file after wait: %v", err)
+			}
+			t.Fatalf("audit content missing turn_id after wait: %s", string(data))
+		}
+		time.Sleep(10 * time.Millisecond)
 	}
 }