fix(audit): catch all write errors so audit failures can't crash requests

AuditLogger.log() raised on any filesystem or serialization failure,
propagating up through _write_audit and the route handler into the
middleware's generic 500 handler. For stream endpoints, the audit call
happens at the end of the event generator so the client still sees the
answer before the stream aborts — but for non-stream /ask and for any
injection-blocked request (which writes audit before returning), the
failure surfaces as "Internal server error" with no indication that
the underlying orchestrator worked fine.

An audit logger that can crash the application is a misdesigned audit
logger. Wrap the write body in try/except Exception, log the failure
via structlog as audit_write_failed, and return normally. This is the
correct contract regardless of the specific filesystem issue — a
misconfigured path, a rotation bug, a serialization bug, or a disk-full
condition should all degrade gracefully to "audit missed, request
served," not take down the request path.

Verified: PermissionError on a root-only path is caught, logged as
audit_write_failed via structlog, and the caller returns normally.
Success path and hash_ip are unchanged.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

agent_bench/security/audit_logger.py

@@ -51,20 +51,33 @@ class AuditLogger:
     def log(self, record: dict) -> None:
         """Append a record to the audit log.
 
-        Adds a timestamp if not present. Thread-safe.
+        Adds a timestamp if not present. Thread-safe. Best-effort: any
+        exception during the write is caught and logged via structlog,
+        never raised. Audit writes must not be able to crash the request
+        path — a misconfigured filesystem, a rotation bug, or a
+        serialization issue should degrade gracefully to "audit missed,
+        request served," not "audit failed, 500 to user."
         """
         if "timestamp" not in record:
             record["timestamp"] = datetime.now(timezone.utc).isoformat()
 
-        with self._lock:
-            self.path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with self._lock:
+                self.path.parent.mkdir(parents=True, exist_ok=True)
 
-            if self.rotate and self.path.exists():
-                if self.path.stat().st_size >= self.max_size_bytes:
-                    self._do_rotate()
+                if self.rotate and self.path.exists():
+                    if self.path.stat().st_size >= self.max_size_bytes:
+                        self._do_rotate()
 
-            with open(self.path, "a") as f:
-                f.write(json.dumps(record, default=str) + "\n")
+                with open(self.path, "a") as f:
+                    f.write(json.dumps(record, default=str) + "\n")
+        except Exception as exc:
+            logger.error(
+                "audit_write_failed",
+                error=str(exc),
+                error_type=type(exc).__name__,
+                path=str(self.path),
+            )
 
     def hash_ip(self, ip: str) -> str:
         """HMAC-SHA256 hash an IP address. Keyed and irreversible."""