fix: bound report issues by bytes, not just count

CI caught the first attempt: the issues array was capped at 100 entries but
not by size. Issues are derived from the same events and carry the same 4 KiB
message and 8 KiB URL, so 100 of them is over a megabyte on its own and the
report still failed to frame.

Both arrays now share one byte-budget helper. The test asserts issue
accounting as well as event accounting, which is the assertion that would have
caught this the first time.

Author: yashranaway

apps/headless/Sources/HeadlessProtocol/Diagnostics.swift

@@ -11,6 +11,10 @@ public final class QADiagnosticStore: @unchecked Sendable {
     /// INVALID_REQUEST for a request that was perfectly valid, so the arrays
     /// are bounded here and the response says what it dropped.
     private let maximumReportEventBytes = 384 * 1_024
+    /// Issues are derived from the same events and carry the same message and
+    /// URL, so a count cap alone is not a size cap: 100 issues built from 4 KiB
+    /// messages and 8 KiB URLs is over a megabyte on its own.
+    private let maximumReportIssueBytes = 192 * 1_024
     private let maximumReportIssues = 100
 
     public init() {}
@@ -81,8 +85,10 @@ public final class QADiagnosticStore: @unchecked Sendable {
         let warnings = issues.count - errors
         // Counts come from the whole snapshot; only the arrays are bounded, so
         // the summary stays accurate even when the payload is trimmed.
-        let boundedIssues = Array(issues.suffix(maximumReportIssues))
-        let boundedEvents = eventsWithinBudget(snapshot)
+        let boundedIssues = valuesWithinBudget(
+            Array(issues.suffix(maximumReportIssues)), bytes: maximumReportIssueBytes
+        )
+        let boundedEvents = valuesWithinBudget(snapshot, bytes: maximumReportEventBytes)
         let omittedIssues = issues.count - boundedIssues.count
         let omittedEvents = snapshot.count - boundedEvents.count
         return .object([
@@ -106,14 +112,14 @@ public final class QADiagnosticStore: @unchecked Sendable {
         ])
     }
 
-    /// Drops the oldest events until the array fits the response budget. Newest
-    /// events are the ones an agent is diagnosing, so they are the ones kept.
-    private func eventsWithinBudget(_ snapshot: [JSONValue]) -> [JSONValue] {
-        var kept = snapshot
-        while kept.count > 1, encodedByteCount(kept) > maximumReportEventBytes {
+    /// Drops the oldest entries until the array fits its budget. Newest entries
+    /// are the ones an agent is diagnosing, so they are the ones kept.
+    private func valuesWithinBudget(_ values: [JSONValue], bytes: Int) -> [JSONValue] {
+        var kept = values
+        while kept.count > 1, encodedByteCount(kept) > bytes {
             kept.removeFirst(max(1, kept.count / 8))
         }
-        if kept.count == 1, encodedByteCount(kept) > maximumReportEventBytes { return [] }
+        if kept.count == 1, encodedByteCount(kept) > bytes { return [] }
         return kept
     }
 

apps/headless/Tests/HeadlessProtocolTests/ProtocolTests.swift

@@ -674,7 +674,8 @@ struct ProtocolTests {
         try expect(object["truncated"] == .bool(true), "a bounded report should report truncation")
         guard case .object(let summary)? = object["summary"],
               case .object(let omitted)? = object["omitted"],
-              case .array(let events)? = object["events"] else {
+              case .array(let events)? = object["events"],
+              case .array(let issues)? = object["issues"] else {
             throw TestFailure(description: "report bounds")
         }
         try expect(summary["events"] == .number(500), "summary counts should describe every event")
@@ -683,6 +684,14 @@ struct ProtocolTests {
             events.count + Int(omitted["events"]?.numberValue ?? 0) == 500,
             "kept plus omitted events should account for the whole buffer"
         )
+        // Issues carry the same message and URL as the events they describe, so
+        // a count cap is not a size cap — bounding them by bytes is what keeps
+        // the report inside the frame.
+        try expect(
+            issues.count + Int(omitted["issues"]?.numberValue ?? 0)
+                == Int(summary["issues"]?.numberValue ?? 0),
+            "kept plus omitted issues should account for every issue"
+        )
     }
 
     static func artifactListingStaysBounded() throws {