Reuse direct BLAS LU workspaces during refactorization

[ChrisRackauckas-Claude]

Ignore this PR until it has been reviewed by @ChrisRackauckas.

Summary

• reuse private mutable LU caches for Apple Accelerate, OpenBLAS, and BLIS, keeping factor, pivot, and LAPACK status storage stable across refactorizations
• pass cached pivot and status buffers positionally through the internal direct-BLAS getrf!/getrs! wrappers, avoiding repeated LU, tuple, Ref, and keyword-argument construction
• give reverse-mode rules a private transient factorization view of direct-BLAS caches, preserving ChainRules/Zygote, Mooncake, and Enzyme behavior without putting wrappers back into the hot path
• convert Accelerate's Int32 pivots to the stdlib BlasInt type only when its transient generic LU view is requested
• cover repeated refactorization, resize, singular failure and recovery, all four BLAS element types, warmed allocations, verbosity, cache container preservation, and AD
• retain the dedicated Apple Accelerate SciMLTesting group on macos-latest for LTS, stable, and pre-release Julia

This changes no public API.

Motivation and root cause

Allocation profiling for SciML/NonlinearSolve.jl#1072 first isolated Apple Accelerate continuation allocations to repeated direct-LU refactorizations. Julia 1.12 testing then exposed the same cache-layout problem in the OpenBLAS and BLIS implementations: each fresh factorization rebuilt LU and tuple wrappers around buffers that already existed, while defaulted keyword arguments could also construct fresh pivot/status objects.

The hot paths now retain the factor matrix, pivot vector, and status reference directly in algorithm-specific caches. Factorization mutates those buffers and returns only the scalar LAPACK status. On Julia 1.12, warmed square refactorizations through both OpenBLAS and BLIS now meet the zero-allocation regression ceiling used by the new tests.

Regression coverage

The direct-BLAS tests exercise OpenBLAS and BLIS for Float32, Float64, ComplexF32, and ComplexF64, including:

• repeated factorization and solution correctness after changing the matrix
• stable factor and pivot buffer identity on same-size refactorization
• zero warmed refactorization allocations on Julia 1.12 and later
• pivot-buffer resizing when the problem dimension changes
• singular-factorization Failure and recovery on the next nonsingular matrix
• construction of a transient factorization view for reverse-mode rules

The Apple Accelerate regression tests check the same factorization view and explicitly emulate its Cint pivot storage on every platform. Zygote/ChainRules, Mooncake, and Enzyme tests compare direct OpenBLAS reverse-mode results against finite differences. Core tests also load the BLIS extension directly so its solver and verbosity paths run in the normal group.

Local verification

• Julia 1.12 GROUP=Core: passed, including Direct BLAS Refactorization Reuse 130/130, Basic 600/600, LU Refactorization Reuse 53/53, Adjoint 26/26, FixedSizeArrays 47/47, ComponentArrays 10/10, ForwardDiff 119/119, Verbosity 66/66, and all remaining Core groups
• Julia 1.12 GROUP=AD: passed; Mooncake 44/44, Static Arrays 23 passed / 1 pre-existing broken, Caching 49 passed / 23 pre-existing broken, Enzyme 49/49
• Julia 1.12 GROUP=QA: passed; Aqua/ExplicitImports 15 passed / 2 pre-existing broken, JET 29 passed / 6 pre-existing broken
• Julia 1.12 GROUP=AppleAccelerate after the generic-view pivot fix: refactorization 55/55; mixed precision 14 passed / 2 pre-existing broken
• Julia 1.10 GROUP=AppleAccelerate after the generic-view pivot fix: refactorization 51/51; mixed precision 14 passed / 2 pre-existing broken
• targeted direct OpenBLAS and BLIS refactorization tests passed on Julia 1.10, 1.12, and 1.13 pre-release before the final AD-view assertion was added; the final Julia 1.12 Core run includes that assertion
• Runic 1.7.0 --check .: passed
• git diff --check: passed

The first expanded CI head exposed that Accelerate stores pivots as Int32, while Julia 1.10's generic LU solve expects stdlib BlasInt (Int64). Commit 27278b6e converts pivots only while constructing the transient AD view, leaving the allocation-free refactorization hot path unchanged.

Current-head CI

The pushed head is terminal with 55 passing checks and 4 intentional skips. Relevant passing lanes include:

• Apple Accelerate on ARM64 macOS with Julia LTS, stable, and pre-release
• Core on Julia LTS, stable, and pre-release
• AD on Julia LTS and stable
• QA, GPU, Runic, Runic Suggestions, downstream packages other than the classified NonlinearSolve baseline, and sublibrary matrices

The three red checks are independently classified and do not report a failure in this change:

• NonlinearSolve downstream fails the tracked Brown almost-linear Broyden baseline (94 passed, 1 failed, 20 broken), documented in NonlinearSolve#1056 and reproduced independently on clean heads.
• Documentation receives three HTTP 429 responses from https://pyamg.readthedocs.io. A clean-main workflow has the identical strict-linkcheck failure, while a later clean-main run passes, confirming intermittent external rate limiting. Separate draft Use stable PyAMG project links #1103 retargets the five project links to PyAMG's official GitHub repository; its full strict local docs build passes without changing linkcheck, warnonly, or ignore settings.
• Downgrade's self-hosted runner lost communication during the test step. GitHub produced no test log and annotated the check as a runner/network disconnect. The automation account lacks repository-admin permission to rerun that reusable workflow.

Julia 1.10 QA baseline

The dense default-solver JET assertion still reports stdlib/Krylov fallback dispatch on Julia 1.10, so the existing unconditional broken expectation is narrowed to Julia versions before 1.12. Julia 1.12 passes that assertion normally.

A separate clean-main investigation also reproduced the KLU JET failure under Julia 1.10. It bisected the first mandatory failure to 45944595 (#1083), which removed the prior broken expectation; #1095 is not causal. Rewriting KLU's extraction call positionally removes its two reports but immediately exposes the same Julia 1.10 NamedTuple/pairs dispatch in required Base/SciMLLogging failure logging, even for standalone @warn. The incomplete code patch was reverted rather than weakening or silencing the assertion. Full evidence is recorded in #1098.

[ChrisRackauckas-Claude]

Implementation/validation scratchpad:

• isolate the Apple-only allocations from the NonlinearSolve continuation profile
• replace transient LU/tuple/Ref construction with private cached workspaces
• update default-adjoint, mixed-precision, ComponentArrays, and FixedSizeArrays paths
• run the full Julia 1.12 Core group, focused Julia 1.12 and 1.10 groups, Runic, and whitespace checks locally
• reproduce and bisect the unrelated clean-main JET/KLU failure; documented separately in KLU JET assertion fails on clean main after #1083 #1098 without weakening QA
• pass the new macOS LTS/stable/pre Accelerate allocation jobs on ARM64
• after merge/release, retest the downstream NonlinearSolve continuation profile against the fixed LinearSolve version

The upstream allocation contract is now verified on all three macOS lanes. The downstream <48-byte continuation claim remains intentionally pending a NonlinearSolve retest against the merged/released dependency.

[ChrisRackauckas-Claude]

macOS LTS failure analysis and follow-up at 2a997ad829b250e3e7ea1e901249d69773bb09c5:

• The first real Accelerate job failed only the unchanged allocation assertion: 64 <= 48 was false on Julia 1.10.11 ARM64.
• I did not raise WRAPPER_CEILING. A local Julia 1.10 harness replaced only the unavailable Accelerate ccalls with allocation-free stubs and reproduced the same 64 bytes, proving the excess was in the solver wrapper.
• Profile.Allocs split those bytes into the expected returned-solution wrapper plus two 16-byte Core.Box allocations. @code_warntype traced the boxes to same-name operation-info bindings captured by lazy logging closures and to a factor-matrix binding that was rebound later.
• Distinct immutable bindings remove that compiler-visible boxing. The same harness now measures 32 bytes on Julia 1.10 (within the existing 48-byte wrapper ceiling) and 0 bytes on Julia 1.12.
• Post-fix local package runs passed:
  • Julia 1.10 AppleAccelerate: refactorization 49/49; mixed precision 14 passed / 2 pre-existing broken
  • Julia 1.12 AppleAccelerate: refactorization 53/53; mixed precision 14 passed / 2 pre-existing broken
  • Runic and git diff --check: clean

A replacement CI run is now required to verify the real Accelerate ccall on macOS LTS/stable/pre.

[ChrisRackauckas-Claude]

Current-head CI classification for 2a997ad829b250e3e7ea1e901249d69773bb09c5:

• The focused Apple Accelerate jobs pass on Apple silicon for Julia 1.10, 1.12, and 1.13. Refactorization reuse passed 55/55, 59/59, and 59/59; each mixed-precision suite passed 19 tests with its one pre-existing broken expectation.
• Core passes on Julia LTS, stable, and prerelease. Formatting, docs, downgrade tests, sublibraries, GPU, and the remaining downstream integrations also pass.
• Trim is a clean-main failure. Exact GROUP=Trim reproduction on 0496f135 fails resolution because the root requires SciMLBase 3.33 while test/Trim pins 2. Bisect found first bad 571d0a868 (Add EigenvalueProblem support with dense, Arpack, ArnoldiMethod, KrylovKit, and JacobiDavidson backends #1071). Focused draft #1093 has been independently verified: 9 passed, 1 pre-existing broken, package tests passed, and its Trim CI lane is green.
• Both AD failures reproduce on clean 0496f135 and were bisected to 459445950ef (LinearSolve 5.0: lightweight solutions — stop populating LinearSolution.cache in solve! returns #1083): successful static solves became cache-free while LU/GESV failure returns still retained the problem, creating the inferred union. Existing focused draft #1094 makes both failure paths cache-free and adds singular LU/GESV regressions. Independent full GROUP=AD runs pass on Julia 1.10.11 and 1.12.6 (Mooncake 41/41, StaticArrays 23 plus 1 pre-existing broken, caching 49 plus 23 pre-existing broken, Enzyme 47/47); both AD CI lanes are green.
• QA's clean-main JET failure was bisected to 459445950ef (LinearSolve 5.0: lightweight solutions — stop populating LinearSolution.cache in solve! returns #1083) and is tracked in #1098.
• The NonlinearSolve downstream job also reproduces exactly against clean LinearSolve 0496f135 and NonlinearSolve 60736b5b6: baseline Broyden is 94 passed / 1 failed / 1 errored / 19 broken. Generalized Rosenbrock was previously bisected to NonlinearSolve 6a7687f542 (Normalize nopre -> QA (+ split AD/Enzyme) #1039) and is tracked in #1081. Existing draft #1057 was independently validated against this exact graph: Base Core and QuasiNewton Core pass (Broyden 810/810; dedicated regression 2/2), and root Broyden becomes 95 passed / 0 failed / 1 errored / 19 broken. The sole remaining error is the separately tracked Brown unexpected pass in #1056.

Every failing job is now reproduced or traced independently of this PR's Apple Accelerate changes, with focused fixes or tracking linked above.

[ChrisRackauckas-Claude]

Implemented the follow-up request, “Do similar changes on those v1.12 failures,” in fe6283ca.

The OpenBLAS and BLIS direct LU paths now follow the Apple Accelerate cache design: factors, pivots, and the LAPACK status reference remain in stable mutable caches, and internal getrf!/getrs! calls take those buffers positionally. Same-size warmed refactorizations therefore avoid rebuilding LU, tuple, keyword, and Ref objects. Resize, singular/recovery, all four BLAS element types, and cache-buffer identity are covered by the new direct-BLAS testset.

Because the cache no longer stores a permanent Factorization, I added a private factorization-view helper used by the ChainRules, Mooncake, and Enzyme reverse rules. Their direct OpenBLAS gradients are checked against finite differences. The BLIS extension is also loaded by Core tests now, which exposed and fixed its stale dictionary-style verbosity access.

Local verification on the final tree:

• Julia 1.12 GROUP=Core: passed; Direct BLAS Refactorization Reuse 130/130 and all other Core groups passed
• Julia 1.12 GROUP=AD: passed; Mooncake 44/44, Static Arrays 23 + 1 existing broken, Caching 49 + 23 existing broken, Enzyme 49/49
• Julia 1.12 GROUP=QA: passed; Aqua/ExplicitImports 15 + 2 existing broken, JET 29 + 6 existing broken
• Runic 1.7.0 --check .: passed
• git diff --check: passed

The branch was rebased onto fce525e2 before this commit. A Julia 1.10 KLU JET failure also reproduced on clean main; that baseline investigation is running separately as required and is not being hidden in this PR.

[ChrisRackauckas-Claude]

Follow-up commit 27278b6e fixes the Apple Accelerate LTS failure reported by the first expanded CI head.

The job's refactorization path passed, but the newly tested transient generic factorization view failed because Accelerate stores LAPACK pivots as Cint/Int32, while Julia 1.10's stdlib LU \ b method requires BlasInt/Int64. The helper now converts the pivot vector only when that transient view is requested by reverse-mode code. The direct Accelerate solve still uses its cached Int32 pivots, so the allocation-free hot path is unchanged.

I added an unguarded regression that constructs an Apple cache with Cint pivots, verifies the resulting view uses LinearAlgebra.BlasInt, and solves correctly. Local results on the final tree:

• Julia 1.12 GROUP=AppleAccelerate: refactorization 55/55; mixed precision 14 passed / 2 existing broken
• Julia 1.10 GROUP=AppleAccelerate: refactorization 51/51; mixed precision 14 passed / 2 existing broken
• Runic 1.7.0 --check .: passed
• git diff --check: passed

Separately, the required clean-main Julia 1.10 KLU investigation is complete. It confirms #1095 is not causal and records the Julia 1.10 logging-dispatch limitation in #1098; no unrelated code or weakened test was added here.

[ChrisRackauckas-Claude]

Final current-head CI classification for 27278b6e:

• 55 checks passed; 4 were intentionally skipped
• Apple Accelerate passed on ARM64 macOS for Julia LTS, stable, and pre-release
• Core passed on Julia LTS, stable, and pre-release
• AD passed on Julia LTS and stable
• QA, GPU, Runic, Runic Suggestions, and the sublibrary matrices passed

Three checks are red, with exact independent classifications:

1. NonlinearSolve downstream reproduces the tracked Brown almost-linear Broyden failure (94 passed, 1 failed, 20 broken), documented in NonlinearSolve#1056.
2. Documentation receives HTTP 429 from https://pyamg.readthedocs.io three times. The separate clean-main investigation found the identical failure in upstream run 29722529521 and confirmed a later main run passes. Strict remediation is in draft Use stable PyAMG project links #1103: all five project links target the official PyAMG GitHub repository, with linkcheck=true and warn/ignore settings unchanged. Its full local docs build, Runic 1.7.0 check, and git diff --check pass.
3. Downgrade has no test assertion/log: GitHub annotated that the self-hosted runner lost communication during julia-runtest. A rerun was attempted but the automation account lacks repository-admin permission for the reusable workflow.

No further code change to this focused PR is indicated by the completed CI.

[ChrisRackauckas-Claude]

Follow-up for the cache-convention review, commit 2c051405:

• Changed factorization lookup to _cache_factorization(alg, cacheval), so cache shape is never interpreted without the solver type.
• Kept the direct Factorization / first-tuple-element behavior only as a documented AbstractFactorization fallback.
• Added solver-specific lookup/reuse dispatch for Apple Accelerate, OpenBLAS, and BLIS custom LU caches.
• Made Krylov, default, and other non-factorization algorithms return nothing regardless of cache shape; regression tests deliberately pass an LU factorization as their cache value.
• Updated ChainRules, Mooncake, and Enzyme reverse rules to pass the algorithm. Enzyme's Krylov branch now extracts .u explicitly.
• Added a safe saved-matrix fallback for factorization algorithms whose opaque cache does not expose a reusable LinearAlgebra.Factorization.

Local verification on Julia 1.12.6:

• GROUP=Core: passed (Adjoint Sensitivity 34/34, Direct BLAS Refactorization Reuse 138/138, LU Refactorization Reuse 56/56; full group ended with Testing LinearSolve tests passed).
• GROUP=AD: passed (Mooncake 46/46, Static Arrays 23 pass + 1 existing broken, Caching Allocation 49 pass + 23 existing broken, Enzyme 49/49).
• GROUP=QA: passed (Quality Assurance 15 pass + 2 existing broken, JET 29 pass + 6 existing broken).
• Repository-wide Runic check passed.

The PR remains draft and should be ignored until reviewed by @ChrisRackauckas.

[ChrisRackauckas-Claude]

CI follow-up for 2c051405:

Implementation-relevant lanes pass:

• Core: Julia 1.12, LTS, and 1.13 prerelease
• AD: Julia 1.12 and LTS
• AppleAccelerate: Julia 1.12, LTS, and prerelease on macOS
• QA, Runic, formatting, GPU, and all tested solver sublibraries

The remaining red checks are independently classified:

• Documentation: three https://pyamg.readthedocs.io link checks returned HTTP 429. This reproduces on clean LinearSolve main. The strict link fix is isolated in draft Use stable PyAMG project links #1103, whose Documentation check passes.
• NonlinearSolve downstream: the exact NLLS Hessian failure reproduces with clean LinearSolve main fce525e2. Independent git bisect run identified NonlinearSolve commit 247a8bfc (Use split ForwardDiff path for RFLUFactorization until slowdown is fixed #1055). Julia 1.10 resolves registered NonlinearSolveBase 2.35.0 rather than the source-tree fix; developing current lib/NonlinearSolveBase passes the case 10/10. Draft NonlinearSolve PR Align the Trim test environment with SciMLBase 3 #1093 carries the required version-bump/release fix, with evidence at Bump NonlinearSolveBase to 2.35.1 and NonlinearSolveFirstOrder to 2.2.2 (release unreleased #1051/#1055 fixes) NonlinearSolve.jl#1093 (comment).
• Downgrade: GitHub reports that the self-hosted runner lost communication while the test step was still in progress. No assertion failure or log blob was produced. The same Downgrade workflow passes on Use stable PyAMG project links #1103.

Local final verification also passed on Julia 1.12.6 (GROUP=Core, GROUP=AD, GROUP=QA) and Julia 1.10.11 (GROUP=Core), plus repository-wide Runic and git diff --check.

Please continue to ignore this draft until reviewed by @ChrisRackauckas.

[ChrisRackauckas-Claude]

Implemented the follow-up factorization audit in 12c4197.\n\n- Replaced the broad AbstractFactorization cache-shape convention with an explicit per-algorithm reuse policy. The direct/tuple cache layout remains only as a documented implementation fallback after a solver family opts in.\n- Audited all 52 package-owned concrete factorization families. Every family now declares direct, extracted, normal-equations, custom, or no reuse; a recursive test rejects future unregistered families.\n- 36 families reuse cached numeric work: 22 direct layouts, 5 extracted layouts, 2 normal-equations layouts, and 7 custom backends.\n- The 16 explicit non-reuse families either have no numeric factorization to reuse or lack a public cache-compatible adjoint solve. Generic reverse rules preserve A and refactorize adjoint(A); AD backends without that fallback report unsupported.\n- NormalCholeskyFactorization and NormalBunchKaufmanFactorization correctly reuse the cached factorization of AᴴA. Their reverse RHS operator solves with that cached factor and then multiplies by A, including rectangular full-column-rank systems.\n- ChainRules, Mooncake, and Enzyme share one cached-adjoint entry point. Krylov reverse solves are also centralized on adjoint(A); this fixes Enzyme's previous transpose(A) behavior for complex matrices.\n- Added custom cached reverse solves for SimpleLU, SparseColumnPivotedQR, Butterfly, MUMPS, Pardiso, HSL MA57, and HSL MA97.\n\nLocal verification:\n- Julia 1.10 GROUP=Core: passed; Adjoint Sensitivity 106/106, Butterfly 44/44.\n- Julia 1.12 GROUP=AD: passed; Mooncake 46/46, Enzyme 49/49, with existing broken-allocation markers unchanged.\n- Julia 1.12 GROUP=QA: QA 15 pass / 2 existing broken; JET 29 pass / 6 existing broken.\n- Julia 1.12 GROUP=LinearSolveMUMPS: 13/13.\n- Julia 1.12 GROUP=LinearSolvePardiso: 91/91, including real and complex cached adjoint solves.\n- Julia 1.12 GROUP=LinearSolveHSL: extension compiled; runtime tests followed the existing skip because the locally installed HSL library is unavailable.\n- Runic 1.7 check and git diff --check: clean.

[ChrisRackauckas-Claude]

CI follow-up for 12c4197: all 57 completed non-skipped code/test checks passed, including AD release/LTS, Core release/LTS/pre, GPU, MUMPS, Pardiso, Apple Accelerate, downstream integration, QA, and formatting. Four matrix entries were intentionally skipped.\n\nThe sole failed check is Documentation. Its log shows Documenter linkcheck received HTTP 429 from https://pyamg.readthedocs.io three times and then exited on linkcheck. This is external rate limiting, not a code or documentation error from this change. I attempted to rerun the failed workflow, but GitHub rejected the request because the connected account does not have repository-admin permission. Please rerun Documentation when convenient.

[ChrisRackauckas-Claude]

Added allocation QA in 139902c1:

• Replaced the direct-BLAS and Apple allocation ceilings with AllocCheck.jl coverage in the QA environment.
• Extracted the same-shape factorization and backsolve operations into backend-dispatched helpers used by the normal OpenBLAS, BLIS, and Apple Accelerate solve! implementations. @check_allocs now checks that exact fast path for Float32, Float64, ComplexF32, and ComplexF64.
• The broad mutable solve! cache signature also contains legitimate value-dependent allocation paths for pivot resizing, rectangular RHS handling, residual-safety backups, and failure reporting. AllocCheck analyzes possible code from types rather than the warmed runtime state, so applying it directly to that whole signature would conflate those fallback paths with the refactorization fast path. The QA test additionally calls the public solve! and requires @allocated(solve!(cache)) == 0 on Julia 1.12+, so the actual public operation is still checked for exactly zero runtime allocation rather than a ceiling.
• Changed the OpenBLAS availability check to the module-load capability constant; this removed the only two dynamic calls AllocCheck found on Julia 1.10.

Local verification:

• Julia 1.12 allocation QA: 48/48 passed.
• Julia 1.10 allocation QA: 40/40 passed.
• Julia 1.12 GROUP=Core: passed.
• Julia 1.10 GROUP=Core: passed.
• Runic 1.7.0 and git diff --check: passed.

Full GROUP=QA currently stops before allocation QA at a clean-main SciMLBase reexport check introduced by 6e50f19d. I reproduced and bisected that separately; draft #1106 contains the isolated fix and passes QA locally.

[ChrisRackauckas-Claude]

Follow-up in 3c26f36a for the Julia 1.13 prerelease allocation failure:

• Julia 1.13 changed JLL library products to lazy library handles. AllocCheck therefore reported two dynamic dispatches at the OpenBLAS getrf and getrs ccall targets, although it found zero allocations.
• OpenBLAS and BLIS now resolve all four scalar variants of getrf and getrs once during module initialization and call fixed runtime function pointers on Julia 1.13+. Julia 1.10 and 1.12 retain the original compile-time library tuple, which is the path AllocCheck accepts there.
• The pointer storage uses runtime-initialized Ref{Ptr{Cvoid}} values so native addresses are never serialized into a precompile cache.

Local verification on the final commit:

• Julia 1.10 allocation QA: 40/40 passed.
• Julia 1.12 allocation QA: 48/48 passed.
• Julia 1.13.0-rc1 allocation QA: 48/48 passed.
• Julia 1.10 GROUP=Core: passed (Testing LinearSolve tests passed).
• Julia 1.12 GROUP=Core: passed.
• Runic 1.7.0 and git diff --check: passed.

The new CI run is in progress. The separate clean-main QA reexport failure remains isolated in draft #1106.

Please continue to ignore this draft until reviewed by @ChrisRackauckas.

[ChrisRackauckas-Claude]

One-hour CI follow-up for 3c26f36a:

• Final matrix: 55 passed, 4 intentionally skipped, 3 failed, 0 pending.
• AppleAccelerate prerelease passed, including the strict Julia 1.13 allocation QA that failed before this commit. Apple stable/LTS, Core stable/LTS/prerelease, GPU, AD, Runic, Documentation, downstream integrations other than NonlinearSolve, and solver sublibraries also passed.

The three red checks are independently classified:

1. QA failed only at the 185 unapproved SciMLBase reexports. This reproduces on clean LinearSolve main and was bisected to 6e50f19d; draft Approve intentional SciMLBase reexports in QA #1106 is the isolated fix and passes QA locally.
2. NonlinearSolve downstream failed Brown almost linear problem 8 with true-Jacobian bad-Broyden on the CI EPYC 9354. Clean current LinearSolve main plus current NonlinearSolve master passes the full Core group on native EPYC 7502, while OPENBLAS_CORETYPE=SANDYBRIDGE deterministically reproduces the CI residual 5.5. Bisect identifies NonlinearSolve 74405d3035, which removed Brown from the broken-case list despite the existing environment-sensitivity report. Full evidence is recorded on Brown bad-Broyden broken test is environment-sensitive NonlinearSolve.jl#1056 (comment). No Reuse direct BLAS LU workspaces during refactorization #1099 source is implicated, and no forbidden broken-test annotation was added.
3. Downgrade has no test failure or completed test log. GitHub reports that the self-hosted runner lost communication while the test step remained in progress. An explicit job rerun request was rejected with HTTP 403 because repository-admin rights are required.

The branch is clean and synchronized with the pushed commit. Please continue to ignore this draft until reviewed by @ChrisRackauckas.