@@ -135,11 +135,17 @@ def attempt_report(report: Path, attempt: int) -> Path:
 
 def finish(report: Path, data: Report, exit_codes: list[int], message: str, *, warning: bool = False) -> None:
     """Publish the final result without presenting recovered failures as current."""
+    details = render_report(data)
     summary = f"## Documentation links\n\n{message}\n\n| Attempt | Exit code |\n| --- | --- |\n"
     summary += "".join(f"| {attempt} | {code} |\n" for attempt, code in enumerate(exit_codes, start=1))
-    summary += f"\n### Final attempt\n\n{render_report(data)}\n"
+    summary += f"\n### Final attempt\n\n{details}\n"
     report.with_suffix(".md").write_text(summary, encoding="utf-8")
+    # CI console logs previously showed only the short message when LYCHEE_REPORT_DIR
+    # forced --format json. Echo the final failure table so broken URLs are visible
+    # without opening the uploaded report artifact (Fixes #3204).
     print(f"::warning::{message}" if warning else message, flush=True)
+    if data.failures:
+        print(details, flush=True)
     if summary_path := os.environ.get("GITHUB_STEP_SUMMARY"):
         with Path(summary_path).open("a", encoding="utf-8") as stream:
             stream.write(summary)
 
@@ -133,13 +133,17 @@ def test_http_timeout_map_entries_are_retryable(tmp_path, code):
     ],
 )
 @pytest.mark.agent_authored(model="gpt-6")
-def test_permanent_or_unknown_failures_stop_without_sleep_or_retry(tmp_path, monkeypatch, failure):
+def test_permanent_or_unknown_failures_stop_without_sleep_or_retry(tmp_path, monkeypatch, capsys, failure):
     report = tmp_path / "lychee.json"
     write_report(report, report_data(errors=[failure]))
     monkeypatch.setattr(retry_lychee.time, "sleep", lambda _delay: pytest.fail("Unexpected sleep"))
 
     assert retry_lychee.retry_lychee(2, report, run_attempt=unexpected_retry) == 2
     assert "permanent or unclassified" in report.with_suffix(".md").read_text(encoding="utf-8")
+    out = capsys.readouterr().out
+    assert "permanent or unclassified" in out
+    assert "| Source | URL | Status |" in out
+    assert retry_lychee.escape_markdown(failure["url"]) in out
 
 
 @pytest.mark.agent_authored(model="gpt-6")
 
@@ -352,12 +352,12 @@ def _parse_headers(header_dict, include_path_list, parser_caching):
             CUDA_VERSION = parser.defs["macros"].get("CUDA_VERSION", "Unknown")
             print(f"Found CUDA_VERSION: {CUDA_VERSION}", flush=True)
 
-        found_types += {key for key in parser.defs["types"]}
-        found_types += {key for key in parser.defs["structs"]}
-        found_types += {key for key in parser.defs["unions"]}
-        found_types += {key for key in parser.defs["enums"]}
-        found_functions += {key for key in parser.defs["functions"]}
-        found_values += {key for key in parser.defs["values"]}
+        found_types += {*parser.defs["types"]}
+        found_types += {*parser.defs["structs"]}
+        found_types += {*parser.defs["unions"]}
+        found_types += {*parser.defs["enums"]}
+        found_functions += {*parser.defs["functions"]}
+        found_values += {*parser.defs["values"]}
 
         for key, value in parser.defs["structs"].items():
             struct_list[key] = _Struct(key, value["members"])
 
@@ -1,7 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Callable
+from typing import Any
+from collections.abc import Callable
 
 from ._ptx_utils import get_minimal_required_cuda_ver_from_ptx_ver, get_ptx_ver
 
 
@@ -1200,7 +1200,7 @@ def main():
         if kernel_number < 8:
             selected_kernel = kernels(kernel_number)
         else:
-            print("Error: kernel number should be between 0 to 7, you have entered %d".format())
+            print(f"Error: kernel number should be between 0 to 7, you have entered {kernel_number}")
             sys.exit(-1)
 
     major = checkCudaErrors(
 
@@ -92,8 +92,7 @@ class TopLevelFinderWithRedirector(_TopLevelFinder):
     """Include the redirector files in the editable wheel."""
 
     def get_implementation(self):
-        for item in super().get_implementation():  # noqa: UP028
-            yield item
+        yield from super().get_implementation()
 
         with open(SITE_PACKAGES / REDIRECTOR_PTH) as f:
             yield (REDIRECTOR_PTH, f.read())
 
@@ -25,7 +25,7 @@ def test_devices_are_the_same_architecture(all_devices):
     # they won't be tested properly.  This tests for the (hopefully rare) case
     # where a system has devices of different architectures and produces a warning.
 
-    all_arches = set(nvml.DeviceArch(nvml.device_get_architecture(device)) for device in all_devices)
+    all_arches = {nvml.DeviceArch(nvml.device_get_architecture(device)) for device in all_devices}
 
     if len(all_arches) > 1:
         warnings.warn(  # noqa: B028
 
@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from ._envvar import envvar_bool
 from ._nvvm_utils import check_nvvm_compiler_options
 
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Sequence
+from collections.abc import Sequence
 
 _PRECHECK_NVVM_IR = """target triple = "nvptx64-unknown-cuda"
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64"
 
@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# Layout is clang-format's job (see .clang-format), so clang-tidy does no
+# formatting of its own (FormatStyle: none below). Each enabled check is meant
+# to be adoptable on its own, so findings can be fixed one check at a time.
+#
+# Checks are opt-in (-*) by group, minus the ones below. They cannot be
+# commented inline because Checks is a single YAML string.
+#
+# Disabled because they conflict with the C-style CUDA driver API idioms:
+#   bugprone-easily-swappable-parameters: wrappers of driver calls take many
+#       adjacent parameters of the same type; the signatures mirror the API.
+#   bugprone-assignment-in-if-condition: `if (CUDA_SUCCESS != (err = CALL(...)))`
+#       is the standard error-handling pattern here.
+#   performance-no-int-to-ptr: opaque handles and file descriptors are
+#       converted to pointers with reinterpret_cast on purpose.
+#   modernize-avoid-c-arrays: arrays are passed to and filled by C APIs.
+#   modernize-return-braced-init-list: `return {};` vs. an explicit type is
+#       left to the author; it adds noise for the driver-API result structs.
+#   bugprone-throwing-static-initialization: the handle registries are
+#       process-lifetime globals whose constructors allocate on some standard
+#       libraries (MSVC); running out of memory while loading the module is
+#       fatal either way.
+#
+# Disabled because they do not match the codebase style:
+#   performance-enum-size: enum underlying types are left as they are.
+#   misc-const-correctness: const on every local is not the convention here.
+#   readability-function-cognitive-complexity: too disruptive.
+#   readability-identifier-length: short names such as the handle parameter `h`
+#       are used throughout.
+#   readability-implicit-bool-conversion: `if (ptr)` and `if (handle)` are the
+#       idiom for pointers and handles.
+#   misc-include-cleaner: too noisy with the CUDA and CPython umbrella headers.
+#   misc-no-recursion: recursion is used deliberately.
+#   misc-use-anonymous-namespace: file-local functions use `static`.
+#   modernize-use-trailing-return-type: the code uses `Type\nname()` layout.
+Checks: >
+  -*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-assignment-in-if-condition,
+  -bugprone-throwing-static-initialization,
+  clang-analyzer-*,
+  misc-*,
+  -misc-include-cleaner,
+  -misc-const-correctness,
+  -misc-no-recursion,
+  -misc-use-anonymous-namespace,
+  modernize-*,
+  -modernize-use-trailing-return-type,
+  -modernize-avoid-c-arrays,
+  -modernize-return-braced-init-list,
+  performance-*,
+  -performance-enum-size,
+  -performance-no-int-to-ptr,
+  readability-*,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
+  -readability-implicit-bool-conversion
+FormatStyle: none
+CheckOptions:
+  # Records whose members are all public (the *Box and guard structs) are plain
+  # data holders; only a mix of public and private members is flagged.
+  misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: true
+WarningsAsErrors: '*'
+# Only report diagnostics for our own headers, not CUDA/CPython/libstdc++.
+HeaderFilterRegex: 'cuda[/\\]core[/\\]_(cpp|include)[/\\]'
+ExcludeHeaderFilterRegex: 'cuda[/\\]core[/\\]_include[/\\](dlpack|aoti_shim)\.h'