fix: fuzzer issue gen (#6481)

## Does this PR closes an open issue or discussion?

<!--
This helps us keep track of fixed issues and changes.
-->

- Closes #.

## What changes are included in this PR?

<!--
What changes are included here, if an issue or discussion are attached,
there's no need to duplicate the details.
-->

## What is the rationale for this change?

<!--
Why do you propose this change, and why did you choose this approach.

This helps reviewers and other readers understand changes, creates a
shared understanding of the issue and codebase,
and improves their ability to work with this change and offer better
suggestions.
-->

## How is this change tested?

<!--
Changes should be tested, we expect changes to fit in one of the
following categories:
1. Verifying existing behavior is maintained.
2. For serialization related changes - Compatibility should be
maintained or explicitly broken.
3. For new behavior and functionality, this helps us maintaining that
desired behavior in the future.
-->

## Are there any user-facing changes?

<!--
Does the change affect users in what of the following ways:
1. Breaks public APIs in some way.
2. Changes the underlying behavior of one of the integrations.
3. Should some documentation be changed to reflect this change?

In the case some public API is changed in a breaking way, make sure to
add the appropriate label.
-->

---------

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

.github/scripts/fuzz_report/cli.py

@@ -5,8 +5,10 @@
 import json
 import os
 import re
+import shlex
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 from .dedup import check_duplicate
@@ -40,6 +42,30 @@ def _write_github_output(key: str, value: str) -> None:
             f.write(f"{key}={value}\n")
 
 
+def _run_gh(cmd: list[str], *, retries: int = 1, **kwargs) -> subprocess.CompletedProcess:
+    """Run a gh CLI command with logging and retry on failure.
+
+    Prints the command before execution and surfaces stderr on failure.
+    Retries up to ``retries`` times (default 1) with a short back-off.
+    """
+    print(f"+ {shlex.join(cmd)}", file=sys.stderr)
+    last_exc: subprocess.CalledProcessError | None = None
+    for attempt in range(1 + retries):
+        if attempt > 0:
+            wait = 5 * attempt
+            print(f"Retrying in {wait}s (attempt {attempt + 1}/{1 + retries})...", file=sys.stderr)
+            time.sleep(wait)
+        try:
+            return subprocess.run(cmd, check=True, **kwargs)
+        except subprocess.CalledProcessError as exc:
+            last_exc = exc
+            stderr_text = (
+                exc.stderr if isinstance(exc.stderr, str) else (exc.stderr or b"").decode()
+            )
+            print(f"gh command failed (exit {exc.returncode}): {stderr_text}", file=sys.stderr)
+    raise last_exc  # type: ignore[misc]
+
+
 def _load_crash_info(path: str | Path) -> CrashInfo:
     """Load CrashInfo from a JSON file."""
     crash_data = json.loads(Path(path).read_text())
@@ -53,6 +79,21 @@ def _find_crash_file(crash_dir: str, crash_name: str) -> str | None:
     return None
 
 
+def _truncate(text: str, max_chars: int) -> str:
+    """Truncate text to max_chars, appending a note if truncated."""
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars] + f"\n... ({len(text) - max_chars} chars truncated)"
+
+
+# GitHub issue body limit is 65536 chars. Reserve ~5k for the fixed template
+# chrome (headings, summary table, reproduction steps, etc.) and split the
+# remaining budget between the two variable-length fields.
+_BODY_BUDGET = 60000
+_TEMPLATE_OVERHEAD = 5000
+_FIELD_BUDGET = _BODY_BUDGET - _TEMPLATE_OVERHEAD  # 55k split between the two
+
+
 def _build_template_variables(
     crash_info: CrashInfo,
     var_args: list[tuple[str, str]] | None = None,
@@ -64,11 +105,28 @@ def _build_template_variables(
         for key, value in var_args:
             variables[key] = value
 
+    panic_msg = crash_info.panic_message
+    stack_trace = crash_info.stack_trace_raw
+
+    # Truncate the two large fields so their combined size fits the budget.
+    combined = len(panic_msg) + len(stack_trace)
+    if combined > _FIELD_BUDGET:
+        # Give panic_message up to half, stack_trace gets the rest.
+        msg_limit = min(len(panic_msg), _FIELD_BUDGET // 2)
+        trace_limit = _FIELD_BUDGET - msg_limit
+        panic_msg = _truncate(panic_msg, msg_limit)
+        stack_trace = _truncate(stack_trace, trace_limit)
+        print(
+            f"Warning: Truncated issue fields to fit body limit "
+            f"(panic_message={msg_limit}, stack_trace={trace_limit})",
+            file=sys.stderr,
+        )
+
     # Auto-populate from crash info (don't override explicit -v args)
     auto_vars = {
-        "PANIC_MESSAGE": crash_info.panic_message,
+        "PANIC_MESSAGE": panic_msg,
         "CRASH_LOCATION": crash_info.crash_location,
-        "STACK_TRACE_RAW": crash_info.stack_trace_raw,
+        "STACK_TRACE_RAW": stack_trace,
         "DEBUG_OUTPUT": crash_info.debug_output,
         "SEED_HASH": crash_info.seed_hash,
         "STACK_TRACE_HASH": crash_info.stack_trace_hash,
@@ -128,7 +186,7 @@ def _update_recurrence_count(repo: str, issue_number: int | str) -> int:
     Returns the new count.
     """
     # List all comments on the issue
-    result = subprocess.run(
+    result = _run_gh(
         [
             "gh",
             "api",
@@ -139,7 +197,6 @@ def _update_recurrence_count(repo: str, issue_number: int | str) -> int:
         ],
         capture_output=True,
         text=True,
-        check=True,
     )
 
     existing_id = None
@@ -161,7 +218,7 @@ def _update_recurrence_count(repo: str, issue_number: int | str) -> int:
     if existing_id:
         # Update existing comment (not atomic — race is acceptable since
         # fuzz CI jobs are serialized)
-        subprocess.run(
+        _run_gh(
             [
                 "gh",
                 "api",
@@ -171,19 +228,17 @@ def _update_recurrence_count(repo: str, issue_number: int | str) -> int:
                 "-f",
                 f"body={body}",
             ],
-            check=True,
         )
     else:
         # Create new recurrence comment
-        subprocess.run(
+        _run_gh(
             [
                 "gh",
                 "api",
                 f"repos/{repo}/issues/{issue_number}/comments",
                 "-f",
                 f"body={body}",
             ],
-            check=True,
         )
 
     return new_count
@@ -302,7 +357,7 @@ def cmd_report(args: argparse.Namespace) -> int:
         body_file = Path("comment_body.md")
         body_file.write_text(body)
 
-        subprocess.run(
+        _run_gh(
             [
                 "gh",
                 "issue",
@@ -313,7 +368,6 @@ def cmd_report(args: argparse.Namespace) -> int:
                 "--body-file",
                 str(body_file),
             ],
-            check=True,
         )
         print(f"Commented on #{existing_issue}", file=sys.stderr)
         _write_github_output("issue_number", str(existing_issue))
@@ -325,7 +379,11 @@ def cmd_report(args: argparse.Namespace) -> int:
         body_file = Path("issue_body.md")
         body_file.write_text(body)
 
-        result = subprocess.run(
+        print(f"Issue title: {title}", file=sys.stderr)
+        print(f"Issue body size: {len(body)} chars", file=sys.stderr)
+        print(f"Repo: {args.repo}", file=sys.stderr)
+
+        result = _run_gh(
             [
                 "gh",
                 "issue",
@@ -339,7 +397,6 @@ def cmd_report(args: argparse.Namespace) -> int:
                 "--body-file",
                 str(body_file),
             ],
-            check=True,
             capture_output=True,
             text=True,
         )
@@ -349,6 +406,36 @@ def cmd_report(args: argparse.Namespace) -> int:
         print(f"Created issue #{issue_number}: {issue_url}", file=sys.stderr)
         _write_github_output("issue_number", issue_number)
 
+        # Post full debug output as a follow-up comment (collapsed).
+        debug_output = variables.get("DEBUG_OUTPUT", "")
+        if debug_output and debug_output != "(not set)":
+            comment_body = (
+                "<details>\n<summary>Debug Output</summary>\n\n"
+                f"```\n{debug_output}\n```\n</details>"
+            )
+            # Truncate comment to GitHub's limit too.
+            if len(comment_body) > _BODY_BUDGET:
+                comment_body = (
+                    comment_body[: _BODY_BUDGET - 50] + "\n```\n</details>\n\n*Truncated*"
+                )
+            comment_file = Path("debug_comment.md")
+            comment_file.write_text(comment_body)
+            try:
+                _run_gh(
+                    [
+                        "gh",
+                        "issue",
+                        "comment",
+                        issue_number,
+                        "--repo",
+                        args.repo,
+                        "--body-file",
+                        str(comment_file),
+                    ],
+                )
+            except subprocess.CalledProcessError:
+                print("Warning: failed to post debug output comment", file=sys.stderr)
+
     return 0
 
 

.github/scripts/fuzz_report/dedup.py

@@ -176,26 +176,6 @@ def check_error_pattern(message_hash: str, error_variant: str, issues: list[dict
                 },
             )
 
-    # Second try: same error variant (lower confidence)
-    if error_variant and error_variant != "unknown":
-        for issue in issues:
-            body = issue.get("body", "")
-            if error_variant in body:
-                return DedupResult(
-                    duplicate=True,
-                    check="error_pattern",
-                    confidence="medium",
-                    issue_number=issue["number"],
-                    issue_url=issue.get("url"),
-                    issue_title=issue.get("title"),
-                    reason=f"Same error variant type: {error_variant}",
-                    debug={
-                        "message_hash": message_hash,
-                        "error_variant": error_variant,
-                        "matched_issue": issue["number"],
-                    },
-                )
-
     return DedupResult(
         duplicate=False,
         check="error_pattern",

.github/scripts/fuzz_report/templates/new_issue.md

@@ -9,26 +9,19 @@
 {{PANIC_MESSAGE}}
 ```
 
-**Stack Trace**:
+<details>
+<summary>Stack Trace</summary>
+
 ```
 {{STACK_TRACE_RAW}}
 ```
+</details>
 {% if CLAUDE_ANALYSIS %}
 
 ### Root Cause Analysis
 
 {{CLAUDE_ANALYSIS}}
 {% endif %}
-{% if DEBUG_OUTPUT %}
-
-<details>
-<summary>Debug Output</summary>
-
-```
-{{DEBUG_OUTPUT}}
-```
-</details>
-{% endif %}
 
 ### Summary
 

.github/scripts/fuzz_report/tests/test_dedup.py

@@ -144,15 +144,13 @@ def test_message_hash_match(self):
         assert result.duplicate is True
         assert result.confidence == "high"
 
-    def test_variant_match(self):
+    def test_variant_only_does_not_match(self):
         result = check_error_pattern(
             "nomatchhash",
             "ScalarMismatch",
             EXISTING_ISSUES,
         )
-        assert result.duplicate is True
-        assert result.confidence == "medium"
-        assert result.issue_number == 101
+        assert result.duplicate is False
 
     def test_no_match(self):
         result = check_error_pattern("nomatch", "UnknownVariant", EXISTING_ISSUES)

.github/scripts/fuzz_report/tests/test_template.py

@@ -197,12 +197,12 @@ def test_claude_analysis_hidden_when_empty(self, new_issue_template):
         rendered = render_template(new_issue_template, vars_no_analysis, use_env=False)
         assert "Root Cause Analysis" not in rendered
 
-    def test_debug_output_in_details(self, new_issue_template):
-        """Debug output should be inside a <details> block."""
+    def test_stack_trace_in_details(self, new_issue_template):
+        """Stack trace should be inside a <details> block."""
         rendered = render_template(new_issue_template, self.SAMPLE_VARS, use_env=False)
         assert "<details>" in rendered
-        assert "Debug Output" in rendered
-        assert "Array { dtype: Int32, len: 10 }" in rendered
+        assert "Stack Trace" in rendered
+        assert "Debug Output" not in rendered
 
     def test_related_comment_target_pattern(self, related_comment_template):
         """Related comment template should also have compatible Target pattern."""

.github/workflows/report-fuzz-crash.yml

@@ -64,13 +64,32 @@ jobs:
         run: pip install -e .github/scripts
 
       - name: Extract crash info
+        id: extract
         run: |
           python3 -m fuzz_report extract \
             logs/fuzz_output.log \
             --crash-dir crash_artifacts \
             --crash-name "${{ inputs.crash_file }}" \
             -o crash_info.json
 
+          # Validate that extraction found a real crash.
+          error_variant=$(jq -r '.error_variant' crash_info.json)
+          panic_message=$(jq -r '.panic_message' crash_info.json)
+          echo "error_variant=$error_variant"
+          echo "panic_message=$panic_message"
+          if [ "$error_variant" = "unknown" ] && [ "$panic_message" = "unknown" ]; then
+            echo "::notice::No crash info found in fuzzer output — nothing to report."
+            echo "crash_found=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "crash_found=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Skip if no crash found
+        if: steps.extract.outputs.crash_found != 'true'
+        run: |
+          echo "No parseable crash in fuzzer output — skipping remaining steps."
+          exit 1
+
       - name: Fetch existing fuzzer issues
         env:
           GH_TOKEN: ${{ secrets.gh_token }}
@@ -116,7 +135,7 @@ jobs:
           claude_args: |
             --model claude-opus-4-6
             --max-turns 5
-            --allowedTools "Read,Write,Bash(cat:*),Bash(jq:*)"
+            --allowedTools "Read,Write,Grep,Glob,Bash(cat:*),Bash(jq:*),Bash(head:*),Bash(xxd:*)"
 
       - name: Create or comment on issue
         id: report