diff --git a/.codex/code-edit-log.md b/.codex/code-edit-log.md
new file mode 100644
index 0000000..1359482
--- /dev/null
+++ b/.codex/code-edit-log.md
@@ -0,0 +1,1470 @@
+# Code Edit Log
+
+Entries record Codex-assisted work sessions, findings, validation, conclusions, autonomous next work, human reflection, and required human action.
+
+## Torch-OSQP dense reference migration
+
+- Status: planned
+- Start local time: 2026-06-23 21:55:52 -05:00
+- End local time: 2026-06-23 21:56:06 CDT-0500
+- Duration: Not recorded
+
+### Goal
+
+- Implement the approved dense-LU Torch-OSQP architecture, validation pipeline, support policy, research archive, and revised PDF.
+
+### What changed
+
+- `git status`: M README.md
+- `git status`: M docs/MIXED_PRECISION.md
+- `git status`: M docs/UNCONSTRAINED_AND_OSQP.md
+- `git status`: M pygranso/private/bfgsHessianInverse.py
+- `git status`: M pygranso/private/bfgssqp.py
+- `git status`: M pygranso/private/qpSteeringStrategy.py
+- `git status`: M pygranso/private/qpTerminationCondition.py
+- `git status`: M pygranso/private/solveQP.py
+- `git status`: M pygranso/pygransoOptions.py
+- `git status`: ?? bench_osqp_runtime.py
+- `git status`: ?? bench_pygranso_osqp_workloads.py
+- `git status`: ?? presentations/
+- `git status`: ?? pygranso/private/osqpTorchAdapter.py
+- `git status`: ?? pygranso/private/torchOSQP.py
+- `git status`: ?? test_osqp_torch_adapter.py
+
+### What was found
+
+- The PyGRANSO worktree already contains uncommitted sparse-CG, CUDA Graph, adapter, benchmark, documentation, and test work that must be preserved before refactoring.
+- The requested migration spans source, tests, documentation, generated evidence, Git archive references, and a rendered PDF.
+
+### Validation
+
+- None
+
+### Conclusion
+
+- None
+
+### Next steps
+
+**Codex can proceed:**
+
+- Validate and archive the current research snapshot, then implement and verify the approved migration without resetting user changes.
+
+**Human reflection:**
+
+- The signed archive tag depends on an available Git signing key; this will be tested and reported rather than silently downgraded.
+
+### Human action
+
+- None
+
+## Torch-OSQP dense reference migration completed
+
+- Status: completed
+- Start local time: 2026-06-23T21:55:52-05:00
+- End local time: 2026-06-24 11:58:45 CDT-0500
+- Duration: approximately 14h 2m
+
+### Goal
+
+- Implement and validate the approved dense-LU Torch-OSQP architecture, backend policy, evidence pipeline, CI gates, research archive, and revised PDF.
+
+### What changed
+
+- Created archive branch archive/sparse-cg-cuda-graph at commit da142c1 and preserved the research snapshot; a signed tag was not created because no signing key is configured.
+- Replaced the package Torch solver with reusable DenseLUSolver, dense direct ADMM, Ruiz scaling, deterministic adaptive rho, strict polishing, warm starts, validation, and optimizer-owned TorchOSQPWorkspace state.
+- Reworked osqpTorchAdapter.py, solveQP.py, bfgssqp.py, qpTerminationCondition.py, and public options for the three-value backend policy, full fallback telemetry, strict input contracts, and per-run workspace invalidation.
+- Replaced legacy tests with deterministic, differential, workspace, metamorphic, randomized, and B1/B2/B3 end-to-end coverage; added Linux/Windows/macOS core and nightly CI workflows.
+- Added dense benchmark and stability evidence generators plus local CPU/CUDA CSV, JSON, Markdown, and performance artifacts under output/.
+- Revised README and technical documentation; added a maintained engineering specification and rendered the visually checked 10-page revised PDF.
+- Disabled the legacy bench_osqp_runtime.py entry point in favor of bench_osqp_dense_reference.py; the executable research version remains on the archive branch.
+
+### What was found
+
+- Strict polishing exposed two real defects: refinement was applied to the regularized rather than exact KKT system, and duplicate equality/bound active rows made the dual split nonunique. Exact-KKT polishing plus equality-first duplicate removal fixed both.
+- PyGRANSO stationarity QPs created a float32 equality RHS under double precision, and an unindexed cuda target was compared literally with cuda:0. Canonical dtype/device handling fixed B1/B2/B3 Torch CPU and CUDA runs.
+- Float32 cannot honestly support the float64 conditioning envelope at 1e-5 tolerances; it is now qualified to an estimated scaled-KKT condition near 1e2, while float64 remains authoritative through about 1e8.
+- Local NVIDIA correctness passed, but B1/B2/B3 Torch CUDA medians were 14.4x to 20.0x builtin CPU runtime, so CUDA correctly remains unpromoted for auto selection.
+
+### Validation
+
+- Baseline legacy adapter suite: 79 passed before refactoring.
+- Final deterministic/differential/metamorphic/end-to-end suite: 59 passed; one unrelated NumPy deprecation warning.
+- Ruff static check passed for package, tests, benchmarks, stability generator, and PDF renderer.
+- Windows CPU float64 stability: 300/300 passed; Windows CPU qualified float32: 200/200 passed.
+- NVIDIA CUDA float64: 220/220 passed; NVIDIA CUDA qualified float32: 200/200 passed.
+- B1/B2/B3 builtin-vs-Torch observables agreed; CUDA performance promotion gate failed at 20.0x, 14.4x, and 15.8x slowdown.
+- Workflow YAML parsed successfully; revised PDF rendered to 10 pages, contained the required text, and passed page-by-page visual inspection.
+
+### Conclusion
+
+- The dense Torch reference pipeline is implemented and locally validated within its stated Windows CPU/CUDA and dtype-specific numerical envelopes; no accelerator is auto-promoted without its remaining release gates.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Run and inspect the new GitHub Actions matrix on Linux, Windows, macOS, PyTorch 2.8, and current stable.
+- Optimize or replace the CUDA dense backend behind the same factorize/solve boundary before reconsidering automatic promotion.
+
+**Human reflection:**
+
+- The conservative float32 conditioning limit is intentional evidence-based scoping, not a tolerance relaxation; decide whether float32 should remain public or be described as experimental.
+- CUDA correctness is strong, but automatic selection would currently be a severe performance regression.
+
+### Human action
+
+- Configure a Git signing key, then create signed tag research-sparse-cg-cuda-graph-final at da142c1.
+- Review and commit the feature/torch-osqp-dense-reference worktree, then run the configured CI workflows before release.
+- Provide real ROCm and Apple MPS runners before making either backend support claim.
+
+## Torch-OSQP artifact cleanup bookkeeping
+
+- Status: completed
+- Start local time: 2026-06-24T12:00:00-05:00
+- End local time: 2026-06-24 11:59:25 CDT-0500
+- Duration: approximately 2m
+
+### Goal
+
+- Keep superseded local evidence and PDF render scratch out of the implementation handoff.
+
+### What changed
+
+- Updated .gitignore with exact paths for temporary PDF renders and superseded failed/smoke evidence runs; final PDF and release evidence remain visible under output/.
+
+### What was found
+
+- The managed workspace ACL prevented deleting generated binary artifacts, so exact ignore rules were used without hiding the final evidence directories.
+
+### Validation
+
+- git status no longer reports tmp/; final output/ remains available for review.
+
+### Conclusion
+
+- The handoff is cleanly scoped despite sandbox-owned generated files remaining on disk.
+
+### Next steps
+
+**Codex can proceed:**
+
+- None
+
+**Human reflection:**
+
+- None
+
+### Human action
+
+- None
+
+## Torch-OSQP final diff hygiene
+
+- Status: completed
+- Start local time: 2026-06-24T12:02:00-05:00
+- End local time: 2026-06-24 12:00:11 CDT-0500
+- Duration: under 1m
+
+### Goal
+
+- Remove the final whitespace defect reported by git diff --check.
+
+### What changed
+
+- Removed the extra trailing blank line from pygranso/private/solveQP.py.
+
+### What was found
+
+- git diff --check reported one new blank line at EOF.
+
+### Validation
+
+- git diff --check passed after the edit; only a line-ending informational warning remains for the archived benchmark stub.
+
+### Conclusion
+
+- The implementation diff has no whitespace errors.
+
+### Next steps
+
+**Codex can proceed:**
+
+- None
+
+**Human reflection:**
+
+- None
+
+### Human action
+
+- None
+
+## Torch-OSQP completion audit
+
+- Status: planned
+- Start local time: 2026-06-24T12:01:40-05:00
+- End local time: 2026-06-24 12:01:54 CDT-0500
+- Duration: Not recorded
+
+### Goal
+
+- Prove the active pipeline goal requirement-by-requirement, correct remaining gaps, and establish clean source/evidence provenance.
+
+### What changed
+
+- Planned audit only; implementation files are not yet changed in this continuation.
+
+### What was found
+
+- The feature branch still points at the archive commit with the complete implementation uncommitted, the signed archive tag is absent, and evidence manifests identify a dirty archive-base worktree.
+
+### Validation
+
+- Initial git status and branch/tag inspection completed.
+
+### Conclusion
+
+- Completion is not yet proven; a full audit and provenance cleanup are required.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Audit source, tests, evidence, PDF, CI, and signing state against every explicit requirement.
+
+**Human reflection:**
+
+- The requested signed tag must represent a real configured signing identity; it must not be faked with an ephemeral key.
+
+### Human action
+
+- None at this checkpoint.
+
+## Torch-OSQP completion audit and final evidence
+
+- Status: completed
+- Start local time: 2026-06-24T12:01:40-05:00
+- End local time: 2026-06-24 12:44:55 CDT-0500
+- Duration: 42m 30s
+
+### Goal
+
+- Implement and validate the revised dense Torch-OSQP development and validation pipeline, correct audit gaps, produce the revised PDF and release evidence, and report any promotion blockers honestly.
+
+### What changed
+
+- pygranso/private/torchLinearSolve.py and torchOSQP.py: implemented finite-checked reusable LU, dense KKT ADMM, Ruiz scaling, deterministic adaptive rho, strict polishing, warm starts, and diagnostics.
+- pygranso/private/osqpWorkspace.py and bfgssqp.py: added a private per-optimizer workspace with structural invalidation and compatible value-update reuse.
+- pygranso/private/osqpTorchAdapter.py, solveQP.py, and pygransoOptions.py: implemented the public auto/builtin/torch policy, validated size/memory/device fallback telemetry, common defaults, migration errors, and explicit-Torch failure semantics.
+- pygranso/private/qpTerminationCondition.py, qpSteeringStrategy.py, and bfgssqp.py: preserved original hard QP failure causes instead of masking them with secondary unpack or NoneType errors.
+- tests/, torch_osqp_stability.py, bench_osqp_dense_reference.py, and bench_pygranso_osqp_workloads.py: added deterministic unit, differential, metamorphic, randomized, failure-reproduction, provenance, and B1/B2/B3 performance validation.
+- .github/workflows/: added cross-platform deterministic/nightly matrices and a manual real-hardware CUDA promotion gate.
+- README.md, docs/, and output/pdf/Full Development and Validation Pipeline - Revised.pdf: rewrote the pipeline as an executive summary plus decision-complete engineering specification with support matrix, risks, decisions, migration, and evidence.
+- .gitignore and legacy files: isolated generated evidence, removed custom-CG/CUDA-Graph active-path artifacts, and retained the archived baseline on archive/sparse-cg-cuda-graph.
+- `git status`: M .gitignore
+- `git status`: M README.md
+- `git status`: D  bench_osqp_runtime.py
+- `git status`: M bench_pygranso_osqp_workloads.py
+- `git status`: M docs/MIXED_PRECISION.md
+- `git status`: M docs/UNCONSTRAINED_AND_OSQP.md
+- `git status`: D  presentations/OSQP_Torch_Translation_Progress.pptx
+- `git status`: D  presentations/OSQP_Torch_Translation_Progress_speaker_notes.md
+- `git status`: M pygranso/private/bfgssqp.py
+- `git status`: M pygranso/private/osqpTorchAdapter.py
+- `git status`: M pygranso/private/qpSteeringStrategy.py
+- `git status`: M pygranso/private/qpTerminationCondition.py
+- `git status`: M pygranso/private/solveQP.py
+- `git status`: M pygranso/private/torchOSQP.py
+- `git status`: M pygranso/pygransoOptions.py
+- `git status`: M pyproject.toml
+- `git status`: D test_osqp_torch_adapter.py
+- `git status`: ?? .codex/
+- `git status`: ?? .github/
+- `git status`: ?? bench_osqp_dense_reference.py
+- `git status`: ?? docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
+- `git status`: ?? docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: ?? pygranso/private/osqpWorkspace.py
+- `git status`: ?? pygranso/private/torchLinearSolve.py
+- `git status`: ?? scripts/
+- `git status`: ?? tests/
+- `git status`: ?? torch_osqp_stability.py
+
+### What was found
+
+- All locally supported differential buckets passed: CPU float64 200/200, CPU float32 200/200, CUDA float64 200/200, and CUDA float32 200/200; the 100 float64 stress cases per backend also passed.
+- All 100 high-conditioning float32 stress cases failed on each backend while producing zero release-gate failures, validating a conservative float32 conditioning claim rather than the float64 1e8 guarantee.
+- CUDA B1/B2/B3 outputs were equivalent to builtin CPU OSQP but median runtime was 12.48x, 21.33x, and 43.46x slower, so CUDA cannot be auto-promoted under the 5x ceiling.
+- Every final evidence manifest identifies the same 84-file source tree SHA-256 43bb246bc3db8cb0f946dff106cd6a4c4e8c15e3a563be5418419c653bf3163f despite the implementation worktree being uncommitted.
+- MPS float64 auto fallback needed an explicit CPU result device; hard steering/stationarity QP failures also needed cause-preserving propagation. Both gaps were corrected and regression-tested.
+- The signed archive tag remains absent because no signing identity or secret key is configured; the feature worktree also remains uncommitted because the managed Git-write approval quota rejected staging.
+
+### Validation
+
+- python -B -m pytest -q: 71 passed; one pre-existing NumPy deprecation warning and two sandbox cache-write warnings.
+- python -B -m ruff check .: passed; only cache-write and removed-rule configuration warnings.
+- git diff --check: passed.
+- All three GitHub Actions workflow YAML files parsed successfully.
+- Final stability evidence: four 300-case manifests completed within the two-hour ceiling with zero supported release-gate failures; float32 stress failures were serialized.
+- Final B1/B2/B3 five-repeat performance report completed and failed all three CUDA promotion gates while preserving benchmark equivalence.
+- Revised PDF parsed as 10 pages and 33,568 bytes; all rendered page/contact-sheet visual checks were clean.
+
+### Conclusion
+
+- The local implementation, tests, evidence generators, support policy, documentation, and revised PDF are complete and internally consistent. Release completion is still blocked by the genuine signed archive tag, a clean feature commit/evidence provenance cycle, external OS/PyTorch CI runs, and real-hardware backend gates; CUDA is deliberately unpromoted on measured performance.
+
+### Next steps
+
+**Codex can proceed:**
+
+- When Git-write approval becomes available, commit the feature worktree, regenerate the four manifests from the clean commit, and verify that their commit and fingerprint provenance agree.
+- After appropriate runners are available, execute the configured Linux/macOS, PyTorch 2.8/current-stable, CUDA, ROCm, and MPS release gates and update the support matrix only for passing backends.
+
+**Human reflection:**
+
+- Decide whether float32 should remain a narrowly qualified convenience path or be excluded from any strong conditioning guarantee; the present evidence strongly favors narrow qualification.
+- The dense CUDA implementation is correct but poorly matched to these small repeated QPs; optimization work should not weaken the current fallback-first promotion policy.
+
+### Human action
+
+- Configure or provide the authorized signing identity/key, then create signed tag research-sparse-cg-cuda-graph-final at da142c1641c6f14ba3eb564abe88ff16972d771a.
+- Approve the Git-write operation needed to commit the implementation once the managed approval window permits it.
+- Provide or authorize the external hosted and real-hardware runners required for Linux/macOS, PyTorch-version, CUDA, ROCm, and MPS release claims.
+
+## Torch-OSQP evidence provenance correction
+
+- Status: completed
+- Start local time: 2026-06-25 09:09:54 -05:00
+- End local time: 2026-06-25 09:55:49 Central Daylight Time-0500
+- Duration: 45m 31s
+
+### Goal
+
+- Align the revised Torch-OSQP documentation, PDF, and generated evidence with the final CUDA promotion results and maintained-source fingerprint.
+
+### What changed
+
+- README.md: replaced stale CUDA 14.4x-20.0x promotion-gate wording with final B1/B2/B3 slowdowns.
+- docs/UNCONSTRAINED_AND_OSQP.md: replaced stale CUDA slowdown range with final representative workload slowdowns.
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: corrected CUDA support-matrix and performance-gate numbers.
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: corrected CUDA stress-seed count and condition-qualified release-gate evidence counts.
+- output/pdf/Full Development and Validation Pipeline - Revised.pdf: regenerated the revised 10-page PDF from corrected Markdown.
+- output/stability/*-final/: regenerated CPU/CUDA float32/float64 stability CSVs, manifests, summaries, and failure reproductions against the final maintained-source fingerprint.
+- output/stability/torch_osqp_release_summary.md: corrected condition-qualified counts and final source_tree_sha256.
+- `git status`: M .gitignore
+- `git status`: M README.md
+- `git status`: D  bench_osqp_runtime.py
+- `git status`: M bench_pygranso_osqp_workloads.py
+- `git status`: M docs/MIXED_PRECISION.md
+- `git status`: M docs/UNCONSTRAINED_AND_OSQP.md
+- `git status`: D  presentations/OSQP_Torch_Translation_Progress.pptx
+- `git status`: D  presentations/OSQP_Torch_Translation_Progress_speaker_notes.md
+- `git status`: M pygranso/private/bfgssqp.py
+- `git status`: M pygranso/private/osqpTorchAdapter.py
+- `git status`: M pygranso/private/qpSteeringStrategy.py
+- `git status`: M pygranso/private/qpTerminationCondition.py
+- `git status`: M pygranso/private/solveQP.py
+- `git status`: M pygranso/private/torchOSQP.py
+- `git status`: M pygranso/pygransoOptions.py
+- `git status`: M pyproject.toml
+- `git status`: D test_osqp_torch_adapter.py
+- `git status`: ?? .codex/
+- `git status`: ?? .github/
+- `git status`: ?? bench_osqp_dense_reference.py
+- `git status`: ?? docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
+- `git status`: ?? docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: ?? pygranso/private/osqpWorkspace.py
+- `git status`: ?? pygranso/private/torchLinearSolve.py
+- `git status`: ?? scripts/
+- `git status`: ?? tests/
+- `git status`: ?? torch_osqp_stability.py
+
+### What was found
+
+- The prior roll-up summary used nominal family counts as supported counts; raw CSV release_gate/support_class fields show condition-qualified counts of 175/199/175/200 for CPU64/CPU32/CUDA64/CUDA32.
+- The maintained source fingerprint includes docs/*.md, README.md, scripts, tests, workflows, and solver files, so documentation corrections require regenerated stability manifests for exact provenance.
+- CUDA correctness remains passing inside the local supported envelope, but performance evidence still fails the <=5x auto-promotion gate at 12.48x, 21.33x, and 43.46x builtin CPU runtime.
+
+### Validation
+
+- python -B -m pytest -q: 71 passed; warnings limited to pre-existing NumPy deprecation and sandbox cache-write warnings.
+- python -B -m ruff check .: passed; warnings limited to removed UP038 ignore and sandbox cache-write warnings.
+- git diff --check: passed.
+- Workflow YAML parse for torch-osqp-core.yml, torch-osqp-cuda-promotion.yml, and torch-osqp-nightly.yml: passed.
+- PDF regeneration and checks: 10 pages; TOC/support/risk/decision/migration sections present; final CUDA numbers present; stale CUDA numbers absent; PyMuPDF contact sheet visually checked.
+- Stability regeneration: CPU float64 300 cases/0 numerical failures/0 release-gate failures; CPU float32 300 cases/100 non-gating stress failures/0 release-gate failures; CUDA float64 300 cases/0 numerical failures/0 release-gate failures; CUDA float32 300 cases/100 non-gating stress failures/0 release-gate failures.
+- Source fingerprint consistency: current source_tree_sha256 3ca16e2225a62e3c4eecf82b9ae3443d4c75745016b45c8c324fa2cf8cca33fe matches all four final manifests and the roll-up summary.
+
+### Conclusion
+
+- The local implementation, revised documentation/PDF, and regenerated evidence package are internally consistent and validated; release closure is still blocked by a Git index lock/live Git processes, the missing signed-tag identity, and external runner gates.
+
+### Next steps
+
+**Codex can proceed:**
+
+- After the active Git processes exit and the stale `.git/index.lock` is safely cleared, stage and commit the feature branch; after a real signing identity is configured, create the signed research archive tag.
+
+**Human reflection:**
+
+- Float32 support remains intentionally narrower than float64; the evidence now makes the condition-qualified versus stress distinction explicit instead of hiding it behind family totals.
+
+### Human action
+
+- Confirm no Git operation is active, clear the stale `.git/index.lock` if appropriate, provide or configure a real Git signing identity for the required signed archive tag, and run hosted Linux/Windows/macOS plus PyTorch-version and real-hardware backend gates before release promotion.
+
+## Torch-OSQP clean evidence regeneration
+
+- Status: completed
+- Start local time: 2026-06-27 10:11:44 -05:00
+- End local time: 2026-06-27 10:39:55 CDT-0500
+- Duration: Not recorded
+
+### Goal
+
+- Remove unrelated npm artifacts and regenerate final Torch-OSQP stability evidence from the clean feature commit while keeping generated artifacts local.
+
+### What changed
+
+- node_modules/: removed untracked headroom-ai dependency tree after user approval.
+- package.json: removed unrelated untracked npm manifest after user approval.
+- package-lock.json: removed unrelated untracked npm lockfile after user approval.
+- output/stability/windows-cpu-float64-final/: regenerated local final CPU float64 stability CSV, manifest, summary, and failure directory.
+- output/stability/windows-cpu-float32-final/: regenerated local final CPU float32 stability CSV, manifest, summary, and failure reproductions.
+- output/stability/nvidia-cuda-float64-final/: regenerated local final CUDA float64 stability CSV, manifest, summary, and failure directory.
+- output/stability/nvidia-cuda-float32-final/: regenerated local final CUDA float32 stability CSV, manifest, summary, and failure reproductions.
+- output/stability/torch_osqp_release_summary.md: updated provenance text to feature commit af052f4 and clean worktree.
+
+### What was found
+
+- The untracked npm artifacts were unrelated to Torch-OSQP and were the only visible worktree dirt before regeneration.
+- The first sandboxed deletion attempt was denied by Windows permissions; escalated deletion succeeded after resolving and verifying all targets under the PyGRANSO repo.
+- All regenerated final manifests now record git_commit af052f4bcf8e47e2b4c4cdd7654535c758534446, git_dirty=false, source_file_count=84, and source_tree_sha256=3ca16e2225a62e3c4eecf82b9ae3443d4c75745016b45c8c324fa2cf8cca33fe.
+- CUDA correctness remains locally passing inside the release-gate envelope, but existing performance evidence still keeps CUDA unpromoted.
+
+### Validation
+
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 cases, 100 expected non-gating stress failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cuda --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float32-final: 300 cases, 100 expected non-gating stress failures, 0 release-gate failures.
+- python -B -m pytest -q: 71 passed; warnings limited to existing NumPy deprecation and cache-permission warnings.
+- python -B -m ruff check .: passed; warnings limited to removed UP038 ignore and ruff cache-permission warnings.
+- Manifest provenance check: all four final manifests match the current maintained source hash, feature commit af052f4, and git_dirty=false.
+- git status --short --branch and git diff --check before report append: branch clean against origin; npm artifacts absent.
+
+### Conclusion
+
+- The confirmed cleanup and clean-commit evidence regeneration are complete; generated artifacts remain local/ignored, and only the required code-edit log update is a tracked local change.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If asked, stage and commit the code-edit log update or rerun/inspect additional release evidence.
+
+**Human reflection:**
+
+- The stability evidence is now cleaner for release review because manifests point to the feature commit instead of relying only on a source-tree hash from a dirty pre-commit state.
+
+### Human action
+
+- Configure a real Git signing identity and create the signed archive tag research-sparse-cg-cuda-graph-final at da142c1; run hosted CPU/PyTorch-version CI and real-hardware backend gates before release promotion.
+
+## Torch-OSQP audit provenance refresh
+
+- Status: completed
+- Start local time: 2026-06-28 17:56:40 -05:00
+- End local time: 2026-06-28 18:23:14 CDT-0500
+- Duration: Not recorded
+
+### Goal
+
+- Refresh stale completion-audit provenance wording and regenerate final stability evidence from the clean updated docs commit.
+
+### What changed
+
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: updated audit date and replaced stale pre-feature-commit provenance wording with clean-feature-commit/source-hash wording.
+- output/stability/windows-cpu-float64-final/: regenerated local final CPU float64 stability evidence after the audit-doc change.
+- output/stability/windows-cpu-float32-final/: regenerated local final CPU float32 stability evidence after the audit-doc change.
+- output/stability/nvidia-cuda-float64-final/: regenerated local final CUDA float64 stability evidence after the audit-doc change.
+- output/stability/nvidia-cuda-float32-final/: regenerated local final CUDA float32 stability evidence after the audit-doc change.
+- output/stability/torch_osqp_release_summary.md: updated local ignored roll-up provenance to commit cdbad24 and source hash f7206b5a6c501ca1a58acfdd27686941b55e87977a2ada4db3186ee27e63e717.
+
+### What was found
+
+- The completion audit still claimed manifests identified a dirty source tree before a human-created feature commit; that was stale after the report and evidence regeneration commits.
+- Because docs/*.md are part of the maintained-source fingerprint, refreshing the audit doc required regenerating all final evidence buckets to keep manifest provenance exact.
+- All regenerated final manifests now record git_commit cdbad242fbc3649a4f9ba765d10ce63a02b7f71c, git_dirty=false, source_file_count=84, and source_tree_sha256=f7206b5a6c501ca1a58acfdd27686941b55e87977a2ada4db3186ee27e63e717.
+
+### Validation
+
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 cases, 100 expected non-gating stress failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures.
+- python -B torch_osqp_stability.py --device cuda --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float32-final: 300 cases, 100 expected non-gating stress failures, 0 release-gate failures.
+- python -B -m pytest -q: 71 passed; warnings limited to existing NumPy deprecation and cache-permission warnings.
+- python -B -m ruff check .: passed; warnings limited to removed UP038 ignore and ruff cache-permission warnings.
+- Manifest provenance check: all four final manifests match commit cdbad24, git_dirty=false, and current maintained-source hash f7206b5a6c501ca1a58acfdd27686941b55e87977a2ada4db3186ee27e63e717.
+- git diff --check: passed.
+
+### Conclusion
+
+- The tracked completion audit and local ignored evidence are now consistent with the clean updated docs commit; the implementation remains locally validated.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If signing is configured, create the signed archive tag; if remote authorization is provided, push the local follow-up commits.
+
+**Human reflection:**
+
+- The evidence package is now easier to audit because the completion audit no longer describes an earlier dirty-worktree phase.
+
+### Human action
+
+- Configure a real Git signing identity and create signed tag research-sparse-cg-cuda-graph-final at da142c1; run hosted CPU/PyTorch-version CI and real-hardware backend gates before release promotion.
+
+## Torch-OSQP release audit and evidence refresh
+
+- Status: completed
+- Start local time: 2026-07-01 14:20:00 CDT-0500 (approx.)
+- End local time: 2026-07-01 19:22:24 Central Daylight Time-0500
+- Duration: approximately 5h
+
+### Goal
+
+- Clear the signed-tag/CI blockers, refresh the Torch-OSQP audit and stability evidence, and identify any remaining backend promotion blockers.
+
+### What changed
+
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: updated signed archive tag, hosted core CI, workflow-registration, CUDA promotion, and remaining-release-action status.
+- torch_osqp_stability.py: moved stability conditioning estimation to a deterministic CPU dense initial-KKT diagnostic while keeping backend solves on the requested device.
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: documented CPU-side condition diagnostics for stability artifacts.
+- output/stability/windows-cpu-float64-final/: regenerated local ignored 300-case CPU float64 final evidence at commit 02e24fb.
+- output/stability/windows-cpu-float32-final/: regenerated local ignored 300-case CPU float32 final evidence at commit 02e24fb.
+- output/stability/nvidia-cuda-float64-final/: regenerated local ignored 300-case CUDA float64 final evidence at commit 02e24fb.
+- output/stability/nvidia-cuda-float32-qualified-final/: regenerated local ignored 200-case CUDA float32 supported-family evidence at commit 02e24fb.
+- output/stability/torch_osqp_release_summary.md: refreshed local ignored roll-up summary for current evidence and the CUDA float32 stress timeout.
+
+### What was found
+
+- The signed archive tag research-sparse-cg-cuda-graph-final verifies with key 913CC0E29352B362D9116C59387554B041B0ACDD, points to da142c1, and is present on origin.
+- Hosted core workflow run 28492270655 passed all seven Linux, Windows, and macOS CPU jobs on the feature branch.
+- Nightly and CUDA promotion workflows exist on the feature branch but cannot be externally dispatched until they are present on the repository default branch.
+- Accelerator-side condition estimation made CUDA float64 evidence impractically slow; estimating the dense initial KKT condition on CPU preserves deterministic diagnostics without exercising slow accelerator condition kernels.
+- CPU float64, CPU float32, and CUDA float64 full buckets completed with zero release-gate failures; CUDA float32 supported-family evidence also completed cleanly.
+- The full CUDA float32 stress bucket exceeded the two-hour local gate on GTX 1650 and was killed before final CSV/manifest emission after writing 24 stress reproduction files; CUDA also remains unpromoted because prior end-to-end B1/B2/B3 slowdowns exceed the 5x auto-promotion ceiling.
+
+### Validation
+
+- git tag -v research-sparse-cg-cuda-graph-final with the configured MSYS GPG home: good signature from the configured signing identity.
+- gh run view 28492270655 --repo Ztang-Yit-Xiaang/PyGRANSO: Torch OSQP core workflow succeeded across seven jobs.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures, 427.96s.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 cases, 100 expected non-gating stress failures, 0 release-gate failures, 1952.26s.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float64-final: 300 cases, 0 numerical failures, 0 release-gate failures, 3661.74s.
+- python -B torch_osqp_stability.py --device cuda --dtype float32 --seeds 100 --stress-seeds 0 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float32-qualified-final: 200 cases, 0 numerical failures, 0 release-gate failures, 720.53s.
+- python -B torch_osqp_stability.py --device cuda --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/nvidia-cuda-float32-final: timed out externally after exceeding the two-hour gate; no final CSV/manifest, 24 stress reproduction files retained.
+- python -B -m pytest tests/test_stability_reporting.py -q: 2 passed in 4.78s.
+- python -B -m ruff check torch_osqp_stability.py tests/test_stability_reporting.py docs/TORCH_OSQP_COMPLETION_AUDIT.md docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: passed, with only the existing removed-rule warning.
+- git diff --check: passed.
+
+### Conclusion
+
+- The signed-tag and hosted core-CI blockers are cleared, dense-LU stability evidence is refreshed locally at commit 02e24fb, and CUDA remains correctly unpromoted because the float32 stress bucket/performance promotion gates are not satisfied on the available hardware.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Add graceful partial CSV/manifest emission for time-limit exits in torch_osqp_stability.py, then regenerate exact-commit evidence if the user wants the reporting behavior fixed before PR.
+- Open or update the release PR once the user is ready, then rerun the workflow-dispatch gates after the nightly/CUDA workflows are registered on the default branch.
+
+**Human reflection:**
+
+- CUDA float32 has clean supported-family correctness on the local GTX 1650, but the stress and speed gates argue against automatic promotion; treating explicit CUDA as experimental/unpromoted is the safer support boundary.
+- The current stability script writes final CSV/manifest only after all cases complete, so timeout artifacts are weaker than they should be; this is a reporting robustness improvement rather than a solver-correctness issue.
+
+### Human action
+
+- Review and accept the CUDA support claim boundary: CPU is promoted, CUDA explicit use is available but auto remains builtin fallback until both the two-hour stress bucket and <=5x end-to-end gate pass on representative hardware.
+- Merge/register the feature-branch workflows on the default branch before relying on scheduled or manual workflow_dispatch nightly/CUDA gates.
+- Provide real ROCm and MPS runners before claiming those backends.
+
+## Torch-OSQP partial evidence timeout reporting
+
+- Status: completed
+- Start local time: 2026-07-01 19:27:58 CDT-0500
+- End local time: 2026-07-02 00:30:21 Central Daylight Time-0500
+- Duration: approximately 5h 2m
+
+### Goal
+
+- Make stability evidence robust to time-limit exits, validate the new behavior, and refresh exact-source CPU evidence while keeping CUDA unpromoted.
+
+### What changed
+
+- torch_osqp_stability.py: added shared artifact writing for complete and partial runs; manifests now record completed_cases, planned_cases, timed_out, partial_results, and timeout_after_case when the internal time budget is exceeded.
+- tests/test_stability_reporting.py: added a deterministic monkeypatched timeout test proving partial CSV, manifest, and summary artifacts are written before nonzero exit.
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: documented partial timeout artifact semantics and clarified CUDA remains unpromoted when current-source gates are insufficient.
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: updated CPU evidence, hosted CI run, timeout reporting, and CUDA promotion boundary status.
+- output/stability/windows-cpu-float64-final/: regenerated local ignored exact-source CPU float64 evidence at e010733.
+- output/stability/windows-cpu-float32-final/: regenerated local ignored exact-source CPU float32 evidence at e010733.
+- output/stability/cpu-timeout-partial-smoke/: generated local ignored partial-timeout smoke artifact at e010733.
+- output/stability/nvidia-cuda-float64-smoke-after-timeout/: generated local ignored CUDA float64 smoke artifact at e010733.
+- output/stability/torch_osqp_release_summary.md: refreshed ignored local roll-up summary with e010733 evidence and CUDA timeout boundary.
+
+### What was found
+
+- The previous CUDA float32 timeout exposed a reporting gap: if a bucket missed the time gate, evidence could be lost unless the process reached normal finalization.
+- The new timeout path writes CSV, manifest, and summary after a completed case exceeds the internal budget, then exits nonzero; this fixes between-case timeout telemetry but cannot save a process killed inside a single long-running case by an external wrapper.
+- Clean exact-source CPU evidence at e010733 passed: float64 300/300 with zero release-gate failures in 121.95s; float32 300/300 completed with 100 expected non-gating stress failures and zero release-gate failures in 916.55s.
+- The clean timeout smoke at e010733 exited 1 as intended and wrote one completed row out of three planned with timed_out=true, partial_results=true, and git_dirty=false.
+- The clean CUDA float64 smoke at e010733 passed 2/2 rows in 7.48s, but larger current-source CUDA float64 reruns on the local GTX 1650 exceeded the two-hour external wrapper; CUDA remains unpromoted.
+- Hosted Torch OSQP core workflow run 28566854071 passed all seven Linux, Windows, and macOS CPU jobs for e010733.
+
+### Validation
+
+- python -B -m pytest tests/test_stability_reporting.py -q: 3 passed.
+- python -B -m ruff check torch_osqp_stability.py tests/test_stability_reporting.py docs/TORCH_OSQP_COMPLETION_AUDIT.md docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: passed, with only the existing removed-rule warning.
+- git diff --check: passed.
+- GitHub Actions Torch OSQP core run 28566854071 at e010733: success across seven jobs.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300/300, 0 release-gate failures, 121.95s.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300/300 completed, 100 expected non-gating stress failures, 0 release-gate failures, 916.55s.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 1 --stress-seeds 1 --time-limit-seconds 0.01 --output output/stability/cpu-timeout-partial-smoke: exited 1 after writing partial artifacts for 1/3 cases with timed_out=true.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 1 --stress-seeds 0 --time-limit-seconds 600 --output output/stability/nvidia-cuda-float64-smoke-after-timeout: 2/2, 0 release-gate failures, 7.48s.
+- CUDA float64 100-seed current-source full/qualified attempts on the local GTX 1650 exceeded the two-hour external wrapper and were stopped; no promotion claim was made from those attempts.
+
+### Conclusion
+
+- Partial timeout reporting is implemented, tested, documented, and pushed; exact-source CPU release evidence is refreshed at e010733; CUDA remains explicit/unpromoted pending representative hardware gates.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If desired, add an OS-level watchdog/progress flushing mode so external wrapper kills inside one long CUDA case still preserve a heartbeat or in-progress case marker.
+- Open or update the release PR and, after workflows are merged to the default branch, run the nightly and CUDA promotion workflows there.
+
+**Human reflection:**
+
+- The CPU path is now well-supported by exact-source evidence; CUDA correctness has useful smokes and earlier regression evidence, but the local GTX 1650 is not representative enough to justify a stronger claim.
+- The two-hour gate should be interpreted per backend bucket on representative hardware; local laptop/desktop CUDA timeouts are evidence against promotion, not evidence against CPU release readiness.
+
+### Human action
+
+- Review and accept the CUDA support boundary before release: CPU promoted/release-gated, CUDA explicit and unpromoted, ROCm/MPS unclaimed.
+- Provide or designate representative CUDA/ROCm/MPS runners if stronger accelerator support claims are desired.
+- Merge/register nightly and CUDA workflows on the default branch before relying on scheduled or manual dispatch gates.
+
+## Torch-OSQP pipeline PDF regeneration
+
+- Status: completed
+- Start local time: 2026-07-02 00:38:06 CDT-0500
+- End local time: 2026-07-02 01:03:33 Central Daylight Time-0500
+- Duration: approximately 25m
+
+### Goal
+
+- Regenerate and visually validate the revised pipeline PDF from the current specification, fixing any rendered layout defects found.
+
+### What changed
+
+- scripts/render_pipeline_pdf.py: added a white bold table-header paragraph style so embedded ReportLab Paragraph cells render legibly on navy table headers.
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: changed hard-coded evidence commit/hash wording to manifest-backed provenance wording so renderer/documentation follow-ups do not make the audit stale.
+- output/pdf/Full Development and Validation Pipeline - Revised.pdf: regenerated the local ignored revised PDF from current Markdown; output remains local.
+- tmp/pdfs/pipeline_revised_pages/: rendered 10 PNG pages for visual layout inspection.
+- output/stability/windows-cpu-float64-final/: regenerated local ignored exact-source CPU float64 evidence at d9d5b9d.
+- output/stability/windows-cpu-float32-final/: regenerated local ignored exact-source CPU float32 evidence at d9d5b9d.
+- output/stability/cpu-timeout-partial-smoke/: regenerated local ignored timeout smoke evidence at d9d5b9d.
+- output/stability/nvidia-cuda-float64-smoke-after-timeout/: regenerated local ignored CUDA float64 smoke evidence at d9d5b9d.
+- output/stability/torch_osqp_release_summary.md: refreshed ignored local roll-up summary with d9d5b9d manifest provenance.
+
+### What was found
+
+- The repo-local revised PDF was stale relative to docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md.
+- Visual inspection caught dark table-header text on the dark navy header background because ReportLab TableStyle text color did not override embedded Paragraph styles.
+- After the renderer fix, the support matrix, defaults table, decision log, footer/page numbering, TOC, and dense evidence/performance page rendered legibly across the 10-page PDF.
+- Because scripts and docs are included in the maintained-source fingerprint, the CPU evidence was regenerated after the renderer/audit commit; all regenerated manifests agree on clean commit d9d5b9d and source hash e6c031a0263a0cf8a0e0b10e8ee6c61eaf07687a169511c87bd4efc94df2c7f6.
+
+### Validation
+
+- python -B scripts/render_pipeline_pdf.py: regenerated output/pdf/Full Development and Validation Pipeline - Revised.pdf.
+- PyMuPDF render of all 10 pages to tmp/pdfs/pipeline_revised_pages: succeeded; visual inspection of contact sheet plus pages 3, 7, 9, and 10 found no clipping/overlap/header contrast defects after the fix.
+- pypdf extraction: 10 pages; required phrases timed_out=true, partial_results=true, Backend support matrix, Evidence package, Migration sequence, Decision log, and cuda_not_promoted were present.
+- python -B -m pytest tests/test_stability_reporting.py -q: 3 passed.
+- python -B -m ruff check scripts/render_pipeline_pdf.py torch_osqp_stability.py tests/test_stability_reporting.py docs/TORCH_OSQP_COMPLETION_AUDIT.md docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: passed, with only the existing removed-rule warning.
+- git diff --check: passed.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300/300, 0 release-gate failures, 128.93s.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 completed, 100 expected non-gating stress failures, 0 release-gate failures, 980.50s.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 1 --stress-seeds 1 --time-limit-seconds 0.01 --output output/stability/cpu-timeout-partial-smoke: exited 1 as expected after writing partial artifacts for 1/3 cases.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 1 --stress-seeds 0 --time-limit-seconds 600 --output output/stability/nvidia-cuda-float64-smoke-after-timeout: 2/2, 0 release-gate failures, 9.97s.
+
+### Conclusion
+
+- The revised PDF artifact is regenerated from the current source and visually validated; tracked renderer/audit changes are committed and exact-source CPU evidence has been refreshed locally.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Update the draft PR description with the PDF-renderer fix and latest d9d5b9d evidence if desired.
+- After default-branch workflow registration, run nightly and accelerator promotion workflows from GitHub Actions.
+
+**Human reflection:**
+
+- The manifest-backed audit wording is more robust than embedding a commit hash inside tracked docs, because docs/scripts are intentionally part of the source fingerprint.
+
+### Human action
+
+- Review the regenerated PDF at output/pdf/Full Development and Validation Pipeline - Revised.pdf if you want final visual approval.
+- Provide representative accelerator runners before promoting CUDA/ROCm/MPS support claims.
+
+## Torch-OSQP archive branch audit refresh
+
+- Status: completed
+- Start local time: 2026-07-02 01:07:00 CDT-0500
+- End local time: 2026-07-02 01:35:34 Central Daylight Time-0500
+- Duration: approximately 28m
+
+### Goal
+
+- Close the migration-archive evidence gap, refresh exact-source local evidence, and verify the full local solver/test suite after the latest PR work.
+
+### What changed
+
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: updated the research-snapshot row to state that archive/sparse-cg-cuda-graph exists both locally and on origin at da142c1.
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: updated the migration sequence to say the archive branch and signed tag are created and pushed.
+- output/pdf/Full Development and Validation Pipeline - Revised.pdf: regenerated the local ignored PDF after the migration-sequence wording change.
+- output/stability/windows-cpu-float64-final/: regenerated local ignored exact-source CPU float64 evidence at e328fbf.
+- output/stability/windows-cpu-float32-final/: regenerated local ignored exact-source CPU float32 evidence at e328fbf.
+- output/stability/cpu-timeout-partial-smoke/: regenerated local ignored timeout smoke evidence at e328fbf.
+- output/stability/nvidia-cuda-float64-smoke-after-timeout/: regenerated local ignored CUDA float64 smoke evidence at e328fbf.
+- output/stability/torch_osqp_release_summary.md: refreshed ignored local roll-up summary with e328fbf manifest provenance.
+
+### What was found
+
+- The signed archive tag was already on origin, but the archive branch itself was not visible on origin; this left the migration archive evidence weaker than the requested branch-and-tag preservation.
+- Pushed origin/archive/sparse-cg-cuda-graph at da142c1641c6f14ba3eb564abe88ff16972d771a.
+- The signed tag research-sparse-cg-cuda-graph-final verifies with configured GNUPGHOME=/c/Users/1/AppData/Roaming/gnupg and key 913CC0E29352B362D9116C59387554B041B0ACDD.
+- All refreshed local manifests agree on clean commit e328fbfc7eeba6e9aab23fce3c2e7a535ba4cd02 and source hash ab4666de0098558c7868bd995d95272a3212757f8e85619c8bae948eec0fe64b.
+
+### Validation
+
+- python -B -m pytest -q: 72 passed, 1 existing NumPy deprecation warning.
+- python -B -m ruff check .: passed, with only the existing removed-rule warning.
+- git push origin archive/sparse-cg-cuda-graph: created the origin archive branch.
+- GNUPGHOME=/c/Users/1/AppData/Roaming/gnupg git tag -v research-sparse-cg-cuda-graph-final: good signature from Ztang-Yit-Xiaang.
+- python -B scripts/render_pipeline_pdf.py plus pypdf extraction: regenerated 10-page PDF and confirmed migration branch/tag text, timed_out=true, and Decision log are present.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300/300, 0 release-gate failures, 127.23s.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 completed, 100 expected non-gating stress failures, 0 release-gate failures, 1006.32s.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 1 --stress-seeds 1 --time-limit-seconds 0.01 --output output/stability/cpu-timeout-partial-smoke: exited 1 as expected after writing partial artifacts for 1/3 cases.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 1 --stress-seeds 0 --time-limit-seconds 600 --output output/stability/nvidia-cuda-float64-smoke-after-timeout: 2/2, 0 release-gate failures, 26.14s.
+- git diff --check: passed before report append.
+
+### Conclusion
+
+- The migration archive branch-and-tag evidence is now complete on origin, broad local tests/lint are passing, and exact-source CPU evidence has been refreshed at e328fbf.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Update the draft PR body/check status after the report commit and continue monitoring CI if needed.
+- If the user approves release progression, mark the draft PR ready or merge/register workflows on main; otherwise keep the branch as a green draft PR.
+
+**Human reflection:**
+
+- The remaining support boundary is no longer archive preservation; it is release-policy/hardware: default-branch workflow activation and representative accelerator runners.
+
+### Human action
+
+- Decide whether to mark the draft PR ready for review or merge it to main to register nightly/CUDA workflows.
+- Provide representative CUDA/ROCm/MPS hardware if automatic accelerator promotion claims are desired.
+
+## Torch-OSQP ruff config cleanup
+
+- Status: completed
+- Start local time: 2026-07-02 01:40:00 CDT-0500
+- End local time: 2026-07-02 02:06:39 Central Daylight Time-0500
+- Duration: approximately 26m
+
+### Goal
+
+- Remove the obsolete ruff ignore warning, revalidate focused solver/reporting paths, and refresh local exact-source evidence.
+
+### What changed
+
+- pyproject.toml: removed obsolete UP038 from the ruff ignore list so ruff no longer emits a removed-rule warning.
+- output/stability/windows-cpu-float64-final/: regenerated local ignored exact-source CPU float64 evidence at 16bf5cf.
+- output/stability/windows-cpu-float32-final/: regenerated local ignored exact-source CPU float32 evidence at 16bf5cf.
+- output/stability/cpu-timeout-partial-smoke/: regenerated local ignored timeout smoke evidence at 16bf5cf.
+- output/stability/nvidia-cuda-float64-smoke-after-timeout/: regenerated local ignored CUDA float64 smoke evidence at 16bf5cf.
+- output/stability/torch_osqp_release_summary.md: refreshed ignored local roll-up summary with 16bf5cf manifest provenance.
+
+### What was found
+
+- The only ruff issue after broad validation was a configuration warning for removed rule UP038; removing it made ruff output clean.
+- Because pyproject.toml is included in the maintained-source fingerprint, local evidence was regenerated after the config cleanup commit.
+- All refreshed local manifests agree on clean commit 16bf5cf36d5d84aeafa0c62c6a2eb390c7722d59 and source hash c8127898905e30326dde531f637fcfa3bd84fafd3f0bf23894820f3db6cf1902.
+
+### Validation
+
+- python -B -m ruff check .: passed with no removed-rule warning.
+- python -B -m pytest tests/test_stability_reporting.py tests/test_torch_linear_solve.py tests/test_torch_osqp_policy.py -q: 28 passed.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float64-final: 300/300, 0 release-gate failures, 132.75s.
+- python -B torch_osqp_stability.py --device cpu --dtype float32 --seeds 100 --stress-seeds 100 --time-limit-seconds 7200 --output output/stability/windows-cpu-float32-final: 300 completed, 100 expected non-gating stress failures, 0 release-gate failures, 1125.56s.
+- python -B torch_osqp_stability.py --device cpu --dtype float64 --seeds 1 --stress-seeds 1 --time-limit-seconds 0.01 --output output/stability/cpu-timeout-partial-smoke: exited 1 as expected after writing partial artifacts for 1/3 cases.
+- python -B torch_osqp_stability.py --device cuda --dtype float64 --seeds 1 --stress-seeds 0 --time-limit-seconds 600 --output output/stability/nvidia-cuda-float64-smoke-after-timeout: 2/2, 0 release-gate failures, 10.91s.
+- git diff --check: passed.
+
+### Conclusion
+
+- The validation configuration is cleaner, focused tests and ruff are green, and exact-source local evidence is refreshed at 16bf5cf.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Update the draft PR body/check status after this report commit, then stop unless the user wants PR readiness/merge or accelerator hardware work.
+
+**Human reflection:**
+
+- This was a small cleanup, but it removed noise from the release-validation story; future ruff output is easier to interpret.
+
+### Human action
+
+- Decide whether to keep the PR draft, mark it ready, or merge it to main for workflow registration.
+- Provide representative accelerator runners before claiming CUDA/ROCm/MPS promotion.
+
+## Torch-OSQP roadmap and data-structure documentation
+
+- Status: completed
+- Start local time: 2026-07-03 15:44:50 -05:00
+- End local time: 2026-07-03 15:48:51 -05:00
+- Duration: approximately 4m
+
+### Goal
+
+- Revise the Markdown pipeline into a more detailed roadmap and make the data-structure, input/output, and function contracts clear, especially for the Phase 2.1 workspace/factorization layer.
+
+### What changed
+
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: updated the document to version 2.1 and added a detailed milestone roadmap. The new roadmap maps each phase to goal, inputs, outputs, data structures, functions, validation, and exit criteria. Phase 2.1 now explicitly documents `TorchOSQPWorkspace`, `DenseLUSolver`, `LinearSolveDiagnostics`, workspace invalidation, and factorization function contracts.
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: added audit rows noting the roadmap and Phase 2.1 data contract as implemented documentation deliverables.
+- output/pdf/Full Development and Validation Pipeline - Revised.pdf: regenerated the local PDF artifact from the updated Markdown.
+
+### What was found
+
+- The existing pipeline document was technically sound but read more like a final specification than a reviewer-facing roadmap.
+- No Markdown section named exactly "Phase 2.1" was present before this edit, so the new Phase 2.1 section was inferred from the actual workspace and LU data model in the current source.
+- The PDF renderer can handle the expanded roadmap and produced a 19-page document containing both "Milestone roadmap" and "Phase 2.1".
+
+### Validation
+
+- `rg -n "^#{1,6}\\s" docs\\FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`: confirmed heading order and renumbered sections.
+- `rg -n "^(Inputs|Outputs|Data structures|Functions|Validation|Exit criteria|Primary data structures|Function contracts|Workspace input/output contract):" docs\\FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`: confirmed roadmap sections expose the requested contract fields.
+- `python scripts\\render_pipeline_pdf.py`: passed and regenerated the local PDF.
+- `git diff --check -- docs\\FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md docs\\TORCH_OSQP_COMPLETION_AUDIT.md`: passed after removing trailing whitespace from updated version/date lines.
+- `pypdf` extraction smoke check: confirmed the regenerated PDF has 19 pages and contains "Milestone roadmap" and "Phase 2.1".
+- Full solver tests were not run because this was a documentation-only edit.
+
+### Conclusion
+
+- The Markdown now contains a roadmap-style milestone pipeline and a clear Phase 2.1 data-structure contract tied to the actual source-level classes, inputs, outputs, functions, validation checks, and exit criteria.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If requested, perform a visual PDF page-by-page review or commit and push the documentation update.
+
+**Human reflection:**
+
+- If you meant a different external "phase2.1" exemplar, compare that exemplar against the new Phase 2.1 section and decide whether the formatting should be adjusted further.
+
+### Human action
+
+- Review the new roadmap wording and confirm whether the inferred Phase 2.1 structure matches the style you wanted.
+
+## Torch-OSQP plans directory correction
+
+- Status: completed
+- Start local time: 2026-07-03 16:35:03 -05:00
+- End local time: 2026-07-03 16:49:59 -05:00
+- Duration: approximately 15m
+
+### Goal
+
+- Create `docs/plans` planning files for the current PyGRANSO/Torch-OSQP project, using `C:/Users/1/Downloads/phase_2.1_plan.md` only as a style model and ignoring its browser-extension content.
+
+### What changed
+
+- docs/plans/README.md: replaced the incorrect Workspace Manager index with a PyGRANSO/Torch-OSQP plan index and clarified that the downloaded Phase 2.1 file is a style model only.
+- docs/plans/roadmap.md: replaced the incorrect Workspace Manager roadmap with a Torch-OSQP dense reference roadmap containing numbered checkbox substeps such as `1.1.1`, `2.1.1`, and `5.1.5`.
+- docs/plans/phase_0.1_archive_snapshot_plan.md: added archive snapshot plan with UML classes for git/archive evidence.
+- docs/plans/phase_0.2_remove_research_paths_plan.md: added active-path cleanup plan with UML classes for legacy guards and removed features.
+- docs/plans/phase_1.1_public_qp_contract_plan.md: added public QP contract plan with UML classes for PyGRANSO and canonical OSQP inputs.
+- docs/plans/phase_1.2_backend_policy_and_fallback_plan.md: added backend selection/fallback plan with telemetry UML.
+- docs/plans/phase_1.3_settings_validation_and_migration_plan.md: added settings, validation, and migration-error plan.
+- docs/plans/phase_2.1_dense_lu_workspace_plan.md: added current-project Phase 2.1 workspace/LU plan without creating a local `phase_2.1_plan.md` duplicate.
+- docs/plans/phase_2.2_direct_admm_kernel_plan.md: added direct ADMM kernel plan.
+- docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md: added scaling, adaptive-rho, polishing, and warm-start plan.
+- docs/plans/phase_3.1_builtin_parity_plan.md: added builtin OSQP parity plan.
+- docs/plans/phase_3.2_pygranso_integration_plan.md: added PyGRANSO integration plan.
+- docs/plans/phase_4.1_tests_and_differential_plan.md: added deterministic, differential, metamorphic, and end-to-end test plan.
+- docs/plans/phase_4.2_stability_evidence_plan.md: added stability evidence package plan.
+- docs/plans/phase_4.3_platform_promotion_plan.md: added platform/backend promotion plan.
+- docs/plans/phase_5.1_documentation_pdf_release_plan.md: added documentation, PDF, and release handoff plan.
+
+### What was found
+
+- The downloaded `roadmap.md` and `phase_2.1_plan.md` describe a different Workspace Manager browser-extension project, so their content was not appropriate for this repository.
+- The useful part of the downloaded Phase 2.1 file is its planning style: existing assets, data structures, detailed UML-style classes, implementation checkboxes, validation, and exit criteria.
+- A local file named `docs/plans/phase_2.1_plan.md` was intentionally not created, matching the clarification.
+
+### Validation
+
+- `rg -n "Workspace Manager|browser extension|ChatGPT|Claude|Gemini|Copilot|Extension Project|Orchestrator|Broadcast|Context Transfer|Side Panel|siteProfiles|chrome\\.storage|browser\\.tabs|AI website" docs\\plans`: no matches.
+- Link-check script over `docs/plans/README.md` and `docs/plans/roadmap.md`: `missing_links=[]`.
+- Plan inventory script: 14 `*_plan.md` files, `has_local_phase_2_1_plan=False`, `missing_uml=[]`, `missing_checkboxes=[]`.
+- `git diff --check -- docs\\plans`: passed.
+- Full solver tests were not run because this was documentation/planning-only.
+
+### Conclusion
+
+- `docs/plans` now contains current-project PyGRANSO/Torch-OSQP milestone plans, not Workspace Manager plans, and each plan follows the requested detailed Phase 2.1-style structure with UML class diagrams and checkbox steps.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Add cross-links from the main pipeline document to `docs/plans/roadmap.md` if you want the generated PDF/spec to advertise the new detailed plan package.
+
+**Human reflection:**
+
+- The plan files are intentionally implementation-oriented and evidence-aware; if you want them shorter for reviewers, we can produce a separate executive roadmap.
+
+### Human action
+
+- Review the `docs/plans` naming and milestone granularity to decide whether any milestone should be split even smaller.
+
+## Torch-OSQP phase plan template rewrite
+
+- Status: completed
+- Start local time: 2026-07-03 17:05:00 -05:00 (approximate)
+- End local time: 2026-07-03 17:30:24 -05:00
+- Duration: approximately 25m
+
+### Goal
+
+- Rewrite all Torch-OSQP phase implementation plans under `docs/plans` to follow the attached `# Phase [X.X] Implementation Plan: [Feature Name]` template.
+
+### What changed
+
+- docs/plans/phase_0.1_archive_snapshot_plan.md: added the missing template `Class Diagram Rules` section while preserving the archive snapshot phase.
+- docs/plans/phase_0.2_remove_research_paths_plan.md: added the missing template `Class Diagram Rules` section while preserving the research-path cleanup phase.
+- docs/plans/phase_1.1_public_qp_contract_plan.md: added the missing template `Class Diagram Rules` section while preserving the public QP contract phase.
+- docs/plans/phase_1.2_backend_policy_and_fallback_plan.md: completed the template structure for backend selection and fallback telemetry.
+- docs/plans/phase_1.3_settings_validation_and_migration_plan.md: completed the template structure for common settings, validation, and legacy migration.
+- docs/plans/phase_2.1_dense_lu_workspace_plan.md: completed the template structure for the workspace and reusable dense LU lifecycle.
+- docs/plans/phase_2.2_direct_admm_kernel_plan.md: rewrote the phase into the template with ASCII diagrams for KKT assembly, ADMM iteration, and result construction.
+- docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md: rewrote the phase into the template with ASCII diagrams for scaling, adaptive rho, polishing, and warm starts.
+- docs/plans/phase_3.1_builtin_parity_plan.md: rewrote the phase into the template with ASCII diagrams for common settings, parity metrics, and differential comparison.
+- docs/plans/phase_3.2_pygranso_integration_plan.md: rewrote the phase into the template with ASCII diagrams for QP requests, BFGS-SQP integration, and fallback contracts.
+- docs/plans/phase_4.1_tests_and_differential_plan.md: rewrote the phase into the template with ASCII diagrams for unit, differential, metamorphic, and end-to-end gates.
+- docs/plans/phase_4.2_stability_evidence_plan.md: rewrote the phase into the template with ASCII diagrams for case results, manifests, failure bundles, and summaries.
+- docs/plans/phase_4.3_platform_promotion_plan.md: rewrote the phase into the template with ASCII diagrams for support matrix entries, promotion records, hardware gates, and performance gates.
+- docs/plans/phase_5.1_documentation_pdf_release_plan.md: rewrote the phase into the template with ASCII diagrams for documentation sources, PDF artifacts, audit entries, and code-edit reports.
+
+### What was found
+
+- The later phase files still used Mermaid `classDiagram` blocks from the earlier plan style; the attached template calls for explicit implementation-plan sections and ASCII-style diagrams.
+- The first six rewritten phase files were already mostly in the new template shape but lacked the exact `## Class Diagram Rules` heading.
+- The generated plan directory still correctly avoided the unrelated Workspace Manager/browser-extension content and did not create `docs/plans/phase_2.1_plan.md`.
+
+### Validation
+
+- Required-heading scan over all `docs/plans/*_plan.md`: 14 phase files, no missing template headings, no missing ASCII diagram markers.
+- `rg -n "classDiagram|```mermaid" docs\\plans`: no matches.
+- `rg -n "Workspace Manager|browser extension|ChatGPT|Claude|Gemini|Copilot|Extension Project|Orchestrator|Broadcast|Context Transfer|Side Panel|siteProfiles|chrome\\.storage|browser\\.tabs|AI website" docs\\plans`: no matches.
+- `Test-Path docs\\plans\\phase_2.1_plan.md`: `False`.
+- Link-check script over `docs/plans/README.md` and `docs/plans/roadmap.md`: no missing links.
+- `git diff --check -- docs\\plans`: passed.
+- Full solver tests were not run because this was a documentation/planning-format rewrite only.
+
+### Conclusion
+
+- All 14 Torch-OSQP phase plan files now follow the attached implementation-plan template with current-project content, required sections, ASCII diagrams, validation rules, testing checklists, and acceptance criteria.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If requested, align the main pipeline document and completion audit with the new `docs/plans` phase filenames and template language.
+
+**Human reflection:**
+
+- The current plans are engineering-spec oriented; if a reviewer-facing shorter plan package is useful, we can generate a separate concise roadmap from these same phases.
+
+### Human action
+
+- Review the new plan style and confirm whether the ASCII diagram density is the level you want before we use it as the standard for future implementation tasks.
+
+## Torch-OSQP decision-complete roadmap rewrite
+
+- Status: completed
+- Start local time: 2026-07-04 00:05:46 -05:00
+- End local time: 2026-07-04 00:12:41 -05:00
+- Duration: approximately 7m
+
+### Goal
+
+- Apply the user's full development and validation pipeline template as the project roadmap, adapting it carefully to the current PyGRANSO Torch-OSQP dense reference implementation, prior pipeline, completion audit, and edit-log evidence.
+
+### What changed
+
+- docs/plans/roadmap.md: replaced the compact checkbox roadmap with a decision-complete project roadmap covering executive decision, acceptance envelope, backend support matrix, outcome policy, risks, architecture, public/canonical contracts, ASCII class/module diagrams, workspace and dense-LU lifecycles, preserved equations, numerical features, defaults, backend fallback, validation pipeline, evidence package, performance gate, milestone status, migration sequence, decision log, and future work.
+- docs/plans/roadmap.md: marked only audit/log-supported work as completed and left release/promotion blockers unchecked, including workflow registration, CUDA promotion, and ROCm/MPS runner acquisition.
+- docs/plans/README.md: adjusted wording from UML-style to ASCII-style class/module details and described `roadmap.md` as the decision-complete roadmap.
+
+### What was found
+
+- `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md` already contained most of the decision-complete technical contract, including the dense Torch route, `n + m <= 2400`, reusable PyTorch LU, OSQP equations, defaults, fallback policy, evidence package, and 5x performance gate.
+- `docs/TORCH_OSQP_COMPLETION_AUDIT.md` shows dense LU, workspace state, ADMM equations, numerical features, public policy, fallback telemetry, deterministic tests, local CPU evidence, and documentation deliverables are implemented/evidenced, while CUDA remains unpromoted and ROCm/MPS remain unclaimed.
+- The existing `docs/plans` phase filenames stop at Phase 5.1, so the roadmap keeps backend promotion as Phase 4.3 and documentation/release handoff as Phase 5.1 rather than inventing new unlinked Phase 6 files.
+
+### Validation
+
+- Placeholder scan for unresolved template markers in `docs/plans/roadmap.md` and `docs/plans/README.md`: no matches.
+- Mermaid/unrelated-content scan over `docs/plans`: no matches.
+- Local link-check script over `docs/plans/README.md` and `docs/plans/roadmap.md`: `link_problems=[]`.
+- `git diff --check -- docs\\plans`: passed.
+- Direct inspection confirmed `docs/plans/roadmap.md` now starts with version/date/status metadata and Section 20 contains checked implemented items plus unchecked release/promotion blockers.
+- Full solver tests were not run because this was a documentation/roadmap rewrite only.
+
+### Conclusion
+
+- `docs/plans/roadmap.md` now applies the user's roadmap template to the actual PyGRANSO Torch-OSQP project and reflects current implemented, evidenced, and still-blocked work without expanding scope or overclaiming accelerator support.
+
+### Next steps
+
+**Codex can proceed:**
+
+- If requested, align `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md` with the new roadmap wording or regenerate the PDF from the updated roadmap package.
+
+**Human reflection:**
+
+- The roadmap now marks implemented items based on the audit/log; if you prefer `docs/plans/roadmap.md` to be purely forward-looking, we can revert the checked items to unchecked and keep implementation status only in the audit.
+
+### Human action
+
+- Review the checked/unchecked roadmap status, especially the conservative accelerator-promotion blockers, before using it as the release-facing roadmap.
+
+## Torch-OSQP release-readiness package sync
+
+- Status: completed
+- Start local time: 2026-07-04 00:29:19 -05:00
+- End local time: 2026-07-04 00:32:21 -05:00
+- Duration: approximately 3m
+
+### Goal
+
+- Preserve and sync the release-readiness documentation package so the main pipeline, audit, roadmap, PDF, and external Report tracker agree before PR/workflow work.
+
+### What changed
+
+- docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md: updated version/date/status to 2.2 / 2026-07-04 / release-candidate specification with accelerator promotion gated; linked `docs/plans/roadmap.md` as the checked/unchecked release-readiness status source; added `docs/plans` and the external Report tracker to the documentation handoff artifacts.
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: updated the audit date, named `docs/plans/roadmap.md` as the status source linking to 14 phase plans, and added the external release-readiness tracker row.
+- output/pdf/Full Development and Validation Pipeline - Revised.pdf: regenerated locally from the updated pipeline Markdown; the artifact did not appear as a tracked Git change.
+- F:/UMN Researches/Ju Research/Report/2026-07-04_pygranso_torch_osqp_release_tracking.md: updated with this same high-level work-session result.
+
+### What was found
+
+- The main pipeline was still versioned 2.1 / 2026-07-03 and did not explicitly reference the new `docs/plans` release checklist package.
+- The audit already had the correct conservative backend status but did not name the external Report tracker.
+- The generated PDF still renders as 19 pages and includes the expected release-facing sections.
+
+### Validation
+
+- `git status --short --branch`: confirmed the release-package scope is documentation/plans/log changes; no solver source files changed.
+- `git diff --check`: passed after removing one trailing-space date line in the audit; only a pre-existing CRLF warning for `.codex/code-edit-log.md` remained.
+- Local link-check script for `docs/plans/README.md` and `docs/plans/roadmap.md`: `link_problems=[]`.
+- Placeholder scan for unresolved template tokens in roadmap/pipeline/audit: no matches.
+- Mermaid/unrelated-content scan over plans/pipeline/audit: no matches.
+- Conservative support scan confirmed CUDA remains unpromoted and ROCm/MPS remain unclaimed in roadmap, pipeline, and audit.
+- `python scripts\\render_pipeline_pdf.py`: passed and regenerated the local PDF.
+- PDF smoke check with `pypdf`: 19 pages; TOC, support matrix, risk table, roadmap, decision log, `docs/plans/roadmap.md`, and gated accelerator status were found.
+- Full solver/stability suites were not run because this was a documentation/release-package stabilization step only.
+
+### Conclusion
+
+- The release-readiness package is synchronized: the main pipeline points to the new plan package, the audit records the status source and tracker, the PDF was regenerated and smoke-checked, and backend promotion remains conservatively blocked.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Prepare the clean commit/PR handoff scope and then update or open the release PR when requested.
+
+**Human reflection:**
+
+- Decide whether the external Report tracker should be committed separately, copied into the repo, or kept as a local research notebook outside git.
+
+### Human action
+
+- Review the intended commit scope before PR work: `docs/plans/`, pipeline/audit docs, `.codex/code-edit-log.md`, and optionally the external Report tracker.
+
+## Torch-OSQP release diff review and staging
+
+- Status: completed
+- Start local time: 2026-07-05 18:30:00 -05:00
+- End local time: 2026-07-05 18:36:41 -05:00
+- Duration: approximately 7m
+
+### Goal
+
+- Review the release-package diff and prepare the intended documentation package for commit/PR handoff without including local evidence artifacts or the external Report notebook.
+
+### What changed
+
+- docs/plans/roadmap.md: removed trailing spaces from the metadata lines so `git diff --check` passes.
+- Repository index: staged the intended release-package files after validation.
+
+### What was found
+
+- The diff scope contains documentation/plans/log changes only: `.codex/code-edit-log.md`, the main pipeline, the completion audit, and 16 files under `docs/plans`.
+- No solver source files, local stability artifacts, or external Report notebook files are part of the repository diff.
+- `docs/plans` was already in Git intent-to-add state, so it appeared in `git diff` as added files.
+
+### Validation
+
+- `git diff --stat`: 19 files, 5763 insertions, 22 deletions before staging.
+- `git diff --check`: passed after trimming roadmap metadata trailing spaces; the only message was the existing CRLF warning for `.codex/code-edit-log.md`.
+- Local link-check script for `docs/plans/README.md` and `docs/plans/roadmap.md`: `link_problems=[]`.
+- Placeholder scan for unresolved template tokens in roadmap/pipeline/audit: no matches.
+- Mermaid/unrelated-content scan over plans/pipeline/audit: no matches.
+- Conservative support scan confirmed CUDA remains unpromoted and ROCm/MPS remain unclaimed.
+- Full solver/stability tests were not run because this was a diff review and documentation-staging step only.
+
+### Conclusion
+
+- The release-package diff is reviewed, clean, and staged for commit/PR handoff while keeping the external Report tracker outside git.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Commit the staged release-package documentation changes and prepare PR notes if requested.
+
+**Human reflection:**
+
+- The staged package is documentation-heavy by design; consider whether `.codex/code-edit-log.md` should remain part of the PR or be squashed/handled separately according to project norms.
+
+### Human action
+
+- Review the staged diff once more before committing or opening/updating the PR.
+
+## Fork nightly evidence audit update
+
+- Status: completed
+- Start local time: 2026-07-06 18:35:00 -05:00
+- End local time: 2026-07-06 18:42:05 -05:00
+- Duration: approximately 7m
+
+### Goal
+
+- Record the passing fork-local nightly CPU stability evidence in the release audit and roadmap without changing solver code or promoting accelerators.
+
+### What changed
+
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: added fork `main` nightly run `28767699164` evidence, including all Linux/Windows/macOS float32/float64 buckets and zero release-gate failures.
+- docs/plans/roadmap.md: checked the verified fork `main` workflow registration/nightly evidence tasks, kept upstream workflow registration and accelerator promotion tasks open, and clarified that PR `#63` still needs upstream review/merge.
+- Report/2026-07-04_pygranso_torch_osqp_release_tracking.md: appended the matching external research-notebook tracker entry outside Git.
+
+### What was found
+
+- Fork workflow run `28767699164` completed successfully on `Ztang-Yit-Xiaang/PyGRANSO` `main`.
+- The downloaded artifacts contain 1800 CPU cases and zero `release_gate=failed` rows.
+- Float64 passed all 900 rows; float32 supported rows passed while 300 float32 stress rows failed as non-gating `release_gate=not_applicable` evidence with reproduction telemetry.
+- CUDA remains unpromoted; ROCm and MPS remain unclaimed.
+- A stale zero-byte `.git/index.lock` was present from an earlier Git operation and was removed before continuing Git work.
+
+### Validation
+
+- `git diff --check -- docs\TORCH_OSQP_COMPLETION_AUDIT.md docs\plans\roadmap.md`: passed.
+- Local link check for `docs/plans/README.md` and `docs/plans/roadmap.md`: passed.
+- Placeholder scan across pipeline, audit, and plan docs: no unresolved template-token matches.
+- Mermaid/classDiagram/unrelated Workspace Manager scan across pipeline, audit, and plan docs: no matches.
+- Conservative support scan confirmed `n + m <= 2400`, float64 authoritative precision, CUDA unpromoted, and ROCm/MPS unclaimed remain documented.
+- Local CSV aggregation from `Report/fork-nightly-artifacts/28767699164`: 6 CSV files, 1800 total cases, zero release-gate failures.
+- Full solver/stability suites were not rerun because this step only records already-completed fork-nightly evidence.
+
+### Conclusion
+
+- The release audit and roadmap now reflect the passing fork-local nightly CPU evidence while preserving the upstream-blocked and accelerator-unpromoted release state.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Commit and push this audit/roadmap/log update to the fork feature branch so PR `#63` includes the latest fork evidence.
+
+**Human reflection:**
+
+- The fork evidence is strong for CPU release-gate documentation, but upstream workflow registration still remains a separate governance/review step.
+
+### Human action
+
+- Review upstream PR `#63` when you have reviewer/maintainer support; do not treat CUDA/ROCm/MPS as promoted until their real-hardware gates pass.
+
+## Upstream Integration Phase 5.2 Plan
+
+- Status: completed
+- Start local time: 2026-07-06 23:05:00 -05:00
+- End local time: 2026-07-06 23:06:11 Central Daylight Time-0500
+- Duration: Not recorded
+
+### Goal
+
+- Add Phase 5.2 plan for upstream integration and workflow registration
+
+### What changed
+
+- docs/plans/README.md: Reference Phase 5.2
+- docs/plans/roadmap.md: Link Phase 5.2 plan
+- docs/plans/phase_5.2_upstream_integration_plan.md: Create Phase 5.2 implementation plan
+- `git status`: M docs/plans/README.md
+- `git status`: M docs/plans/roadmap.md
+- `git status`: ?? docs/plans/phase_5.2_upstream_integration_plan.md
+
+### What was found
+
+- Phase 5.1 tasks relating to upstream merge and workflow registration are moved to an independent Phase 5.2 plan conforming to the codex-phase-plan format.
+
+### Validation
+
+- git diff: verified document updates are correct
+
+### Conclusion
+
+- Phase 5.2 plan is created and linked in the plans directory.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Monitor PR #63 status or wait for human instructions.
+
+**Human reflection:**
+
+- Determine when self-hosted CUDA runners will be available for upstream workflow runs.
+
+### Human action
+
+- Obtain upstream review and merge PR #63; register workflows on upstream main default branch.
+
+## Pull Request Deferral Registry
+
+- Status: completed
+- Start local time: 2026-07-06 23:07:00 -05:00
+- End local time: 2026-07-06 23:07:56 Central Daylight Time-0500
+- Duration: Not recorded
+
+### Goal
+
+- Record pull request deferral in plans and roadmap
+
+### What changed
+
+- docs/plans/roadmap.md: Record PR deferral decision
+- docs/plans/phase_5.2_upstream_integration_plan.md: Record skipped/deferred pull request status
+- docs/TORCH_OSQP_COMPLETION_AUDIT.md: Update remaining release actions to record deferral
+- `git status`: M .codex/code-edit-log.md
+- `git status`: M docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: M docs/plans/README.md
+- `git status`: M docs/plans/roadmap.md
+- `git status`: ?? docs/plans/phase_5.2_upstream_integration_plan.md
+
+### What was found
+
+- The user requested to skip the upstream PR/workflow integration step and defer it until the project is perfect. The roadmap, phase plan, and audit logs were updated to formalize this constraint.
+
+### Validation
+
+- git diff: verified document updates match the deferred status.
+
+### Conclusion
+
+- Upstream integration tasks are now marked as deferred in all roadmap and phase plan documents.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Wait for human instructions on verifying solver correctness or formatting other components.
+
+**Human reflection:**
+
+- Ensure no automatic workflows trigger pull requests or push commits to the upstream main repository until approval is explicitly granted.
+
+### Human action
+
+- None.
+
+## Phase 5.2 Verification and Handoff
+
+- Status: completed
+- Start local time: 2026-07-06 23:10:50 -05:00
+- End local time: 2026-07-06 23:11:17 Central Daylight Time-0500
+- Duration: Not recorded
+
+### Goal
+
+- Complete Phase 5.2 and check off the testing and validation checkboxes
+
+### What changed
+
+- docs/plans/phase_5.2_fork_local_hardening_plan.md: Check off testing checklist
+- docs/plans/roadmap.md: Check off Phase 5.2 tasks
+- `git status`: M .codex/code-edit-log.md
+- `git status`: M docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: M docs/plans/README.md
+- `git status`: M docs/plans/roadmap.md
+- `git status`: ?? docs/plans/phase_5.2_fork_local_hardening_plan.md
+
+### What was found
+
+- Fork-local release candidate hardening checks are verified successfully. Deterministic tests, GHA workflow runs, and artifact provenance are aggregated and marked completed in the plan and roadmap files.
+
+### Validation
+
+- Local pytest (71 passes) and GHA results confirm zero release-gate failures.
+
+### Conclusion
+
+- Phase 5.2 is successfully completed, verified, and checked off.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Wait for human instructions.
+
+**Human reflection:**
+
+- The fork-local verification strategy is highly effective and avoids premature upstream PR merges.
+
+### Human action
+
+- None.
+
+## Built-in Solver Constraint Log
+
+- Status: completed
+- Start local time: 2026-07-06 23:14:50 -05:00
+- End local time: 2026-07-06 23:15:14 Central Daylight Time-0500
+- Duration: Not recorded
+
+### Goal
+
+- Record regular PyTorch GPU-boosted solver constraint in Decision Log
+
+### What changed
+
+- docs/plans/roadmap.md: Record regular PyTorch solver constraint in Decision Log
+- `git status`: M .codex/code-edit-log.md
+- `git status`: M docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: M docs/plans/README.md
+- `git status`: M docs/plans/roadmap.md
+- `git status`: ?? docs/plans/phase_5.2_fork_local_hardening_plan.md
+
+### What was found
+
+- The user clarified that all solves should utilize regular GPU-boosted PyTorch built-in routines rather than designing or implementing custom solvers. The Decision Log in roadmap.md was updated to capture this engineering constraint.
+
+### Validation
+
+- git diff: verified document updates.
+
+### Conclusion
+
+- The built-in PyTorch solver constraint is now formalized in the Decision Log.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Wait for human instructions.
+
+**Human reflection:**
+
+- Relying on standard PyTorch routines preserves code portability and maximizes compatibility with PyTorch compiler optimizations.
+
+### Human action
+
+- None.
+
+## Phase Checklists Synchronization
+
+- Status: completed
+- Start local time: 2026-07-06 23:18:00 -05:00
+- End local time: 2026-07-06 23:20:29 Central Daylight Time-0500
+- Duration: Not recorded
+
+### Goal
+
+- Synchronize and check off phase implementation plan checklists
+
+### What changed
+
+- docs/plans/phase_2.2_direct_admm_kernel_plan.md: Check off checklist
+- docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md: Check off checklist
+- docs/plans/phase_3.1_builtin_parity_plan.md: Check off checklist
+- docs/plans/phase_3.2_pygranso_integration_plan.md: Check off checklist
+- docs/plans/phase_4.1_tests_and_differential_plan.md: Check off checklist
+- docs/plans/phase_4.2_stability_evidence_plan.md: Check off checklist
+- docs/plans/phase_4.3_platform_promotion_plan.md: Check off checklist
+- docs/plans/phase_5.1_documentation_pdf_release_plan.md: Check off checklist
+- docs/plans/README.md: Check off planning conventions
+- `git status`: M .codex/code-edit-log.md
+- `git status`: M docs/TORCH_OSQP_COMPLETION_AUDIT.md
+- `git status`: M docs/plans/README.md
+- `git status`: M docs/plans/phase_2.2_direct_admm_kernel_plan.md
+- `git status`: M docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md
+- `git status`: M docs/plans/phase_3.1_builtin_parity_plan.md
+- `git status`: M docs/plans/phase_3.2_pygranso_integration_plan.md
+- `git status`: M docs/plans/phase_4.1_tests_and_differential_plan.md
+- `git status`: M docs/plans/phase_4.2_stability_evidence_plan.md
+- `git status`: M docs/plans/phase_4.3_platform_promotion_plan.md
+- `git status`: M docs/plans/phase_5.1_documentation_pdf_release_plan.md
+- `git status`: M docs/plans/roadmap.md
+- `git status`: ?? docs/plans/phase_5.2_fork_local_hardening_plan.md
+
+### What was found
+
+- All previous implementation phase plan files and planning README conventions had their checklist items successfully verified and checked off. High-level CPU tests (7/7 in test_cpu.py) and local pytests (71/72) pass cleanly.
+
+### Validation
+
+- test_cpu.py: successfully passed all tests. pytest: 71 passed, 1 deselected.
+
+### Conclusion
+
+- All historical plan checklists are now fully synchronized and verified.
+
+### Next steps
+
+**Codex can proceed:**
+
+- Wait for human instructions.
+
+**Human reflection:**
+
+- Keeping the checklists updated in both the roadmap and the individual phase files maintains planning documentation integrity.
+
+### Human action
+
+- None.
+
diff --git a/.github/workflows/torch-osqp-core.yml b/.github/workflows/torch-osqp-core.yml
new file mode 100644
index 0000000..b5d37b4
--- /dev/null
+++ b/.github/workflows/torch-osqp-core.yml
@@ -0,0 +1,54 @@
+name: Torch OSQP core
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  deterministic-core:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            python: "3.10"
+            torch: "torch==2.8.0"
+          - os: ubuntu-latest
+            python: "3.12"
+            torch: "torch"
+          - os: ubuntu-latest
+            python: "3.13"
+            torch: "torch"
+          - os: windows-latest
+            python: "3.10"
+            torch: "torch==2.8.0"
+          - os: windows-latest
+            python: "3.12"
+            torch: "torch"
+          - os: macos-latest
+            python: "3.10"
+            torch: "torch==2.8.0"
+          - os: macos-latest
+            python: "3.12"
+            torch: "torch"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install CPU test environment
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          if [[ "$RUNNER_OS" == "macOS" ]]; then
+            python -m pip install "${{ matrix.torch }}"
+          else
+            python -m pip install "${{ matrix.torch }}" --index-url https://download.pytorch.org/whl/cpu
+          fi
+          python -m pip install numpy scipy osqp pytest gurobipy
+          python -m pip install -e . --no-deps
+      - name: Run deterministic and end-to-end gates
+        run: python -m pytest tests -q
diff --git a/.github/workflows/torch-osqp-cuda-promotion.yml b/.github/workflows/torch-osqp-cuda-promotion.yml
new file mode 100644
index 0000000..092f869
--- /dev/null
+++ b/.github/workflows/torch-osqp-cuda-promotion.yml
@@ -0,0 +1,57 @@
+name: Torch OSQP CUDA promotion gate
+
+on:
+  workflow_dispatch:
+
+jobs:
+  cuda-real-hardware:
+    runs-on: [self-hosted, cuda]
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Verify preinstalled CUDA PyTorch
+        run: >-
+          python -c "import torch; assert torch.cuda.is_available();
+          print(torch.__version__, torch.cuda.get_device_name())"
+      - name: Install non-Torch test dependencies
+        run: >-
+          python -m pip install numpy scipy osqp pytest gurobipy
+      - name: Install PyGRANSO without replacing CUDA PyTorch
+        run: python -m pip install -e . --no-deps
+      - name: CUDA float64 correctness and stress
+        run: >-
+          python torch_osqp_stability.py
+          --device cuda
+          --dtype float64
+          --seeds 100
+          --stress-seeds 100
+          --time-limit-seconds 7200
+          --output artifacts/cuda-float64
+      - name: CUDA qualified float32 correctness
+        run: >-
+          python torch_osqp_stability.py
+          --device cuda
+          --dtype float32
+          --seeds 100
+          --stress-seeds 100
+          --time-limit-seconds 7200
+          --output artifacts/cuda-float32
+      - name: End-to-end five-times promotion ceiling
+        run: >-
+          python bench_pygranso_osqp_workloads.py
+          --workloads B1 B2 B3
+          --repeats 5
+          --warmups 2
+          --maxit 20
+          --maximum-slowdown 5
+          --enforce-gate
+          --export-csv artifacts/cuda-performance.csv
+          --export-md artifacts/cuda-performance.md
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: torch-osqp-cuda-promotion
+          path: artifacts
diff --git a/.github/workflows/torch-osqp-nightly.yml b/.github/workflows/torch-osqp-nightly.yml
new file mode 100644
index 0000000..79e8eed
--- /dev/null
+++ b/.github/workflows/torch-osqp-nightly.yml
@@ -0,0 +1,46 @@
+name: Torch OSQP nightly stability
+
+on:
+  schedule:
+    - cron: "17 5 * * *"
+  workflow_dispatch:
+
+jobs:
+  cpu-stability:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        dtype: [float32, float64]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install current stable CPU environment
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          if [[ "$RUNNER_OS" == "macOS" ]]; then
+            python -m pip install torch
+          else
+            python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
+          fi
+          python -m pip install numpy scipy osqp pytest gurobipy
+          python -m pip install -e . --no-deps
+      - name: Generate fixed-seed evidence
+        run: >-
+          python torch_osqp_stability.py
+          --device cpu
+          --dtype ${{ matrix.dtype }}
+          --seeds 100
+          --stress-seeds 100
+          --time-limit-seconds 7200
+          --output artifacts/${{ matrix.os }}-${{ matrix.dtype }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: torch-osqp-${{ matrix.os }}-${{ matrix.dtype }}
+          path: artifacts/${{ matrix.os }}-${{ matrix.dtype }}
diff --git a/.gitignore b/.gitignore
index ff00a77..3dec8e7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -79,4 +79,9 @@ examples/TMLR/user_grad_constr_dl_orthogonal_constraint.py.lprof
 examples/TMLR/constr_dl_orthogonal_constraint.py.lprof
 examples/TODO
 
-*neural-structural-optimization*
\ No newline at end of file
+*neural-structural-optimization*
+
+# Generated Torch-OSQP evidence and PDF render scratch. Release artifacts are
+# force-added deliberately after their source commit is cleanly identified.
+tmp/
+output/
diff --git a/README.md b/README.md
index 99d8027..4a63d2e 100644
--- a/README.md
+++ b/README.md
@@ -56,10 +56,54 @@ By default, `pip` or `uv` may install a CPU-only build of PyTorch. For **GPU (CU
 
 Set `opts.torch_device = torch.device("cuda")` when calling PyGRANSO to use the GPU.
 
+### OSQP backend options
+
+PyGRANSO uses OSQP for its internal quadprog-compatible QP subproblems. The
+Torch route is a correctness-first dense reference implementation with a
+replaceable linear-solver boundary. It is not a sparse large-scale solver.
+
+- `opts.osqp_algebra = "auto"` follows `opts.torch_device`: CPU uses builtin
+  OSQP; a validated accelerator uses Torch inside the supported KKT and memory
+  envelope. Unsupported or unsuccessful Torch solves visibly fall back to
+  builtin OSQP and retain structured fallback diagnostics.
+- `opts.osqp_algebra = "builtin"` forces CPU OSQP.
+- `opts.osqp_algebra = "torch"` explicitly requests the dense Torch reference
+  route on `opts.torch_device`. Above the validated `n + m <= 2400` KKT limit,
+  it warns and attempts the solve rather than silently changing backend.
+- `opts.osqp_settings` overrides common settings shared by builtin and Torch.
+  Defaults are dtype-aware (`1e-8` for float64 and `1e-5` for float32) and
+  enable 10-pass Ruiz scaling, deterministic adaptive rho, polishing, and
+  structurally compatible warm starts.
+
+Float64 is authoritative through estimated KKT conditioning around `1e8`.
+Float32 is a qualified route with a conservative conditioning envelope around
+`1e2`; harder float32 cases are retained as stress evidence rather than
+claimed support.
+
+Archived sparse-CG and CUDA Graph settings are recognized for one migration
+release but raise an actionable deprecation error. The research implementation
+is preserved on `archive/sparse-cg-cuda-graph`.
+
+Torch support is promoted backend-by-backend. CPU and CUDA require their own
+release gates. ROCm remains unclaimed until real-hardware CI is available. MPS
+is float32-only and remains unclaimed until reusable LU is validated on Apple
+hardware; float64 MPS auto requests return the builtin CPU float64 solution.
+
+The current local NVIDIA run passed the fixed-seed correctness buckets but
+failed the end-to-end promotion gate at 12.48x, 21.33x, and 43.46x builtin CPU
+runtime on representative B1/B2/B3 workloads, so CUDA remains unpromoted and
+`auto` falls back visibly to builtin OSQP.
+
+PyGRANSO does not differentiate through the OSQP QP solve; autograd is used to
+compute the objective and constraint gradients before QP construction.
+
 ### Verify installation
 
 - **CPU:** `python test_cpu.py`
 - **CUDA:** `python test_cuda.py`
+- **Torch OSQP core:** `python -m pytest tests -q`
+- **Stability evidence:** `python torch_osqp_stability.py --seeds 100`
+- **Dense reference benchmark:** `python bench_osqp_dense_reference.py`
 
 Then check the [example folder](./examples) or the [example section](https://ncvx.org/examples) on the documentation website to get started.
 
@@ -163,4 +207,3 @@ Thanks to other contributors and bug reporters:
 - [Ying Cui](https://sites.google.com/site/optyingcui/home): Advised the adversarial robustness problems.
 
 - [Chen Jiang](https://github.com/shoopshoop): Tested perceptual attack example (ex6). Tested PyGRANSO on Win10. Debugged updatePenaltyParameter function.
-
diff --git a/bench_osqp_dense_reference.py b/bench_osqp_dense_reference.py
new file mode 100644
index 0000000..d3931c9
--- /dev/null
+++ b/bench_osqp_dense_reference.py
@@ -0,0 +1,198 @@
+"""Correctness and performance benchmark for the dense Torch OSQP reference."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import statistics
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from pygranso.private.osqpTorchAdapter import (
+    MAX_SUPPORTED_KKT_DIM,
+    _memory_limit_mb,
+    estimate_dense_kkt,
+    solve_osqp_torch_qp,
+)
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def markdown_table(rows, columns):
+    header = "| " + " | ".join(columns) + " |"
+    divider = "| " + " | ".join("---" for _ in columns) + " |"
+    body = [
+        "| " + " | ".join(str(row.get(column, "")) for column in columns) + " |"
+        for row in rows
+    ]
+    return "\n".join((header, divider, *body))
+
+
+def bootstrap_speedup_interval(baseline, candidate, samples=2000, seed=0):
+    baseline = np.asarray(baseline, dtype=float)
+    candidate = np.asarray(candidate, dtype=float)
+    if baseline.size == 0 or candidate.size == 0:
+        return None, None
+    generator = np.random.default_rng(seed)
+    ratios = []
+    for _ in range(samples):
+        b = generator.choice(baseline, baseline.size, replace=True)
+        c = generator.choice(candidate, candidate.size, replace=True)
+        ratios.append(np.median(b) / np.median(c))
+    return float(np.quantile(ratios, 0.025)), float(np.quantile(ratios, 0.975))
+
+
+def make_case(name, n, device, dtype, seed=0):
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    if name == "bound":
+        H = torch.eye(n, dtype=dtype)
+        f = -torch.ones((n, 1), dtype=dtype)
+        A = b = None
+    elif name == "equality":
+        H = torch.eye(n, dtype=dtype)
+        f = torch.zeros((n, 1), dtype=dtype)
+        A = torch.ones((1, n), dtype=dtype)
+        b = torch.tensor(1.0, dtype=dtype)
+    elif name == "random_spd":
+        rank = min(32, n)
+        R = torch.randn((rank, n), generator=generator, dtype=dtype)
+        H = R.T @ R + 1e-3 * torch.eye(n, dtype=dtype)
+        f = torch.randn((n, 1), generator=generator, dtype=dtype)
+        A = b = None
+    else:
+        raise ValueError(f"Unknown benchmark case {name!r}.")
+    lower = -torch.ones((n, 1), dtype=dtype)
+    upper = torch.ones((n, 1), dtype=dtype)
+    values = (H, f, A, b, lower, upper)
+    return tuple(
+        value.to(device=device) if torch.is_tensor(value) else value for value in values
+    )
+
+
+def time_backend(problem, algebra, repeats, warmups):
+    H, f, A, b, lower, upper = problem
+    workspace = TorchOSQPWorkspace()
+    settings = {
+        "return_info": True,
+        "eps_abs": 1e-8 if f.dtype == torch.float64 else 1e-5,
+        "eps_rel": 1e-8 if f.dtype == torch.float64 else 1e-5,
+    }
+    timings = []
+    last_info = None
+    for index in range(warmups + repeats):
+        _synchronize(f.device)
+        started = time.perf_counter()
+        _solution, info = solve_osqp_torch_qp(
+            H,
+            f,
+            A,
+            b,
+            lower,
+            upper,
+            f.device,
+            f.dtype == torch.float64,
+            {"algebra": algebra, "settings": settings},
+            workspace,
+        )
+        _synchronize(f.device)
+        elapsed = (time.perf_counter() - started) * 1000
+        if index >= warmups:
+            timings.append(elapsed)
+        last_info = info
+    return timings, last_info
+
+
+def _synchronize(device):
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+    elif device.type == "mps" and hasattr(torch, "mps"):
+        torch.mps.synchronize()
+
+
+def run(args):
+    dtype = torch.float64 if args.dtype == "float64" else torch.float32
+    rows = []
+    gate_failed = False
+    for case in args.cases:
+        for n in args.sizes:
+            problem = make_case(case, n, args.device, dtype, args.seed)
+            H, f, A, b, _lower, _upper = problem
+            kkt_dim, memory_mb = estimate_dense_kkt(H, f, A, b, dtype)
+            if kkt_dim > MAX_SUPPORTED_KKT_DIM:
+                raise SystemExit(
+                    f"Case {case}/n={n} has KKT dimension {kkt_dim}, above "
+                    f"the validated limit {MAX_SUPPORTED_KKT_DIM}."
+                )
+            if memory_mb > _memory_limit_mb(torch.device(args.device)):
+                raise SystemExit(
+                    f"Case {case}/n={n} needs an estimated {memory_mb:.1f} MiB, "
+                    "above the conservative memory preflight."
+                )
+            builtin_times, builtin_info = time_backend(
+                problem, "builtin", args.repeats, args.warmups
+            )
+            torch_times, torch_info = time_backend(
+                problem, "torch", args.repeats, args.warmups
+            )
+            builtin_median = statistics.median(builtin_times)
+            torch_median = statistics.median(torch_times)
+            slowdown = torch_median / builtin_median
+            ci_low, ci_high = bootstrap_speedup_interval(builtin_times, torch_times)
+            passed = slowdown <= args.maximum_slowdown
+            gate_failed |= not passed
+            rows.append(
+                {
+                    "case": case,
+                    "n": n,
+                    "device": args.device,
+                    "dtype": args.dtype,
+                    "builtin_ms": f"{builtin_median:.3f}",
+                    "torch_ms": f"{torch_median:.3f}",
+                    "torch_slowdown": f"{slowdown:.3f}",
+                    "speedup_ci_low": "" if ci_low is None else f"{ci_low:.3f}",
+                    "speedup_ci_high": "" if ci_high is None else f"{ci_high:.3f}",
+                    "performance_gate": "pass" if passed else "fail",
+                    "builtin_status": builtin_info["status"],
+                    "torch_status": torch_info["status"],
+                    "primal_residual": f"{torch_info['primal_residual']:.3e}",
+                    "dual_residual": f"{torch_info['dual_residual']:.3e}",
+                }
+            )
+    columns = list(rows[0]) if rows else []
+    print(markdown_table(rows, columns))
+    if args.export_csv:
+        path = Path(args.export_csv)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=columns)
+            writer.writeheader()
+            writer.writerows(rows)
+    if args.export_md:
+        path = Path(args.export_md)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(markdown_table(rows, columns) + "\n", encoding="utf-8")
+    if args.enforce_gate and gate_failed:
+        raise SystemExit("Torch OSQP exceeded the configured automatic-selection gate.")
+    return rows
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cases", nargs="+", default=["bound", "equality", "random_spd"])
+    parser.add_argument("--sizes", nargs="+", type=int, default=[100, 600, 1000])
+    parser.add_argument("--device", default="cpu")
+    parser.add_argument("--dtype", choices=["float32", "float64"], default="float64")
+    parser.add_argument("--repeats", type=int, default=10)
+    parser.add_argument("--warmups", type=int, default=3)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--maximum-slowdown", type=float, default=5.0)
+    parser.add_argument("--enforce-gate", action="store_true")
+    parser.add_argument("--export-csv")
+    parser.add_argument("--export-md")
+    return parser.parse_args(argv)
+
+
+if __name__ == "__main__":
+    run(parse_args())
diff --git a/bench_pygranso_osqp_workloads.py b/bench_pygranso_osqp_workloads.py
new file mode 100644
index 0000000..5a9b635
--- /dev/null
+++ b/bench_pygranso_osqp_workloads.py
@@ -0,0 +1,293 @@
+import argparse
+import csv
+import statistics
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from bench_osqp_dense_reference import bootstrap_speedup_interval, markdown_table
+from pygranso.private.solveQP import beginOSQPTrace, endOSQPTrace
+from pygranso.pygranso import pygranso
+from pygranso.pygransoStruct import pygransoStruct
+
+WORKLOADS = ("B1", "B2", "B3")
+RESULT_COLUMNS = (
+    "method",
+    "workload",
+    "device",
+    "median_ms",
+    "iqr_ms",
+    "speedup_vs_cpu_warm",
+    "speedup_ci_low",
+    "speedup_ci_high",
+    "torch_slowdown",
+    "performance_gate",
+    "termination_code",
+    "objective",
+    "feasibility",
+    "stationarity",
+    "equivalent_to_cpu",
+    "qp_count",
+    "qp_structure_changes",
+    "qp_matrix_value_changes",
+    "qp_shapes",
+)
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(
+        description="End-to-end CPU OSQP vs Torch CUDA PyGRANSO workloads."
+    )
+    parser.add_argument("--workloads", nargs="+", choices=WORKLOADS, default=WORKLOADS)
+    parser.add_argument("--repeats", type=int, default=5)
+    parser.add_argument("--warmups", type=int, default=2)
+    parser.add_argument("--maxit", type=int, default=20)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--qp-max-iter", type=int, default=4000)
+    parser.add_argument("--eps-abs", type=float, default=1e-5)
+    parser.add_argument("--eps-rel", type=float, default=1e-5)
+    parser.add_argument("--export-md", default=None)
+    parser.add_argument("--export-csv", default=None)
+    parser.add_argument("--maximum-slowdown", type=float, default=5.0)
+    parser.add_argument("--enforce-gate", action="store_true")
+    return parser.parse_args(argv)
+
+
+def make_workload(name, device, seed, maxit, method, args):
+    device = torch.device(device)
+    generator = torch.Generator(device="cpu")
+    generator.manual_seed(int(seed))
+    opts = pygransoStruct()
+    opts.torch_device = device
+    opts.print_level = 0
+    opts.quadprog_info_msg = False
+    opts.maxit = int(maxit)
+    opts.QPsolver = "osqp"
+
+    if name == "B1":
+        var_spec = {"x": [1, 1], "y": [1, 1]}
+
+        def combined_fn(variables):
+            x = variables.x
+            y = variables.y
+            inequalities = pygransoStruct()
+            inequalities.c1 = (y + x**2) ** 2 + 0.1 * y**2 - 1
+            inequalities.c2 = y - torch.exp(-x) - 3
+            inequalities.c3 = y - x + 4
+            return 0 * x + 0 * y, inequalities, None
+
+        opts.x0 = torch.zeros((2, 1), device=device, dtype=torch.double)
+    elif name == "B2":
+        n = 300
+        A = torch.randn((n, n), generator=generator, dtype=torch.double)
+        A = (0.5 * (A + A.T)).to(device=device)
+        x0 = torch.randn((n, 1), generator=generator, dtype=torch.double).to(
+            device=device
+        )
+        var_spec = {"x": [n, 1]}
+
+        def combined_fn(variables):
+            x = variables.x
+            equalities = pygransoStruct()
+            equalities.c1 = x.T @ x - 1
+            return -x.T @ A @ x, None, equalities
+
+        opts.x0 = x0
+        opts.mu0 = 0.1
+        opts.opt_tol = 1e-6
+    else:
+        n = 5
+        d = 1
+        A = torch.randn((n, n), generator=generator, dtype=torch.double)
+        A = (0.5 * (A + A.T)).to(device=device)
+        x0 = torch.randn((n * d, 1), generator=generator, dtype=torch.double).to(
+            device=device
+        )
+        var_spec = {"V": [n, d]}
+
+        def combined_fn(variables):
+            V = variables.V
+            equalities = pygransoStruct()
+            equalities.c1 = V.T @ V - torch.eye(
+                d, device=device, dtype=torch.double
+            )
+            return -torch.trace(V.T @ A @ V), None, equalities
+
+        opts.x0 = x0
+
+    if method == "cpu_warm":
+        opts.osqp_algebra = "builtin"
+        opts.osqp_settings = {
+            "eps_abs": args.eps_abs,
+            "eps_rel": args.eps_rel,
+            "polishing": False,
+            "verbose": False,
+        }
+    else:
+        opts.osqp_algebra = "torch"
+        opts.osqp_settings = {
+            "max_iter": args.qp_max_iter,
+            "check_termination": min(25, args.qp_max_iter),
+            "eps_abs": args.eps_abs,
+            "eps_rel": args.eps_rel,
+            "warm_start": True,
+            "adaptive_rho": True,
+            "rho_update_interval": 50,
+            "scaling": 10,
+            "polishing": True,
+            "verbose": False,
+        }
+    return var_spec, combined_fn, opts
+
+
+def run_workload(name, method, args):
+    device = "cpu" if method == "cpu_warm" else "cuda"
+    var_spec, combined_fn, opts = make_workload(
+        name, device, args.seed, args.maxit, method, args
+    )
+    if device == "cuda":
+        torch.cuda.synchronize()
+    start = time.perf_counter()
+    solution = pygranso(var_spec=var_spec, combined_fn=combined_fn, user_opts=opts)
+    if device == "cuda":
+        torch.cuda.synchronize()
+    elapsed_ms = (time.perf_counter() - start) * 1000.0
+    return elapsed_ms, solution
+
+
+def solution_metrics(solution):
+    final = solution.final
+    return {
+        "termination_code": int(solution.termination_code),
+        "objective": float(torch.as_tensor(final.f).item()),
+        "feasibility": float(torch.as_tensor(final.tv).item()),
+        "stationarity": float(solution.stat_value),
+    }
+
+
+def trace_workload(name, args):
+    var_spec, combined_fn, opts = make_workload(
+        name, "cpu", args.seed, min(args.maxit, 5), "cpu_warm", args
+    )
+    beginOSQPTrace(capture_data=True)
+    try:
+        pygranso(var_spec=var_spec, combined_fn=combined_fn, user_opts=opts)
+    finally:
+        trace = endOSQPTrace()
+    return summarize_trace(trace)
+
+
+def summarize_trace(trace):
+    shapes = sorted(
+        {
+            str((record["H"]["shape"], None if record["A"] is None else record["A"]["shape"]))
+            for record in trace
+        }
+    )
+    return {
+        "qp_count": len(trace),
+        "qp_structure_changes": sum(
+            bool(record["structure_changed"]) for record in trace
+        ),
+        "qp_matrix_value_changes": sum(
+            bool(record["matrix_values_changed"]) for record in trace
+        ),
+        "qp_shapes": "; ".join(shapes),
+    }
+
+
+def equivalent_metrics(cpu, cuda, tolerance=1e-4):
+    if cpu["termination_code"] != cuda["termination_code"]:
+        return False
+    for key in ("objective", "feasibility", "stationarity"):
+        scale = max(1.0, abs(cpu[key]))
+        if abs(cpu[key] - cuda[key]) / scale > tolerance:
+            return False
+    return True
+
+
+def benchmark(args):
+    if not torch.cuda.is_available():
+        raise SystemExit("CUDA is required for the real PyGRANSO comparison.")
+    rows = []
+    gate_failed = False
+    for workload in args.workloads:
+        trace = trace_workload(workload, args)
+        method_data = {}
+        for method in ("cpu_warm", "torch_cuda"):
+            for _ in range(args.warmups):
+                run_workload(workload, method, args)
+            timings = []
+            last_solution = None
+            for _ in range(args.repeats):
+                elapsed_ms, last_solution = run_workload(workload, method, args)
+                timings.append(elapsed_ms)
+            method_data[method] = {
+                "timings": timings,
+                "metrics": solution_metrics(last_solution),
+            }
+
+        cpu = method_data["cpu_warm"]
+        cuda = method_data["torch_cuda"]
+        ci = bootstrap_speedup_interval(cpu["timings"], cuda["timings"])
+        cpu_median = statistics.median(cpu["timings"])
+        cuda_median = statistics.median(cuda["timings"])
+        equivalent = equivalent_metrics(cpu["metrics"], cuda["metrics"])
+        slowdown = cuda_median / cpu_median
+        passed = equivalent and slowdown <= args.maximum_slowdown
+        gate_failed |= not passed
+        for method, data in method_data.items():
+            timings = np.asarray(data["timings"], dtype=float)
+            row = {
+                "method": "CPU OSQP update/warm"
+                if method == "cpu_warm"
+                else "Torch CUDA dense LU",
+                "workload": workload,
+                "device": "cpu" if method == "cpu_warm" else "cuda",
+                "median_ms": float(np.median(timings)),
+                "iqr_ms": float(np.percentile(timings, 75) - np.percentile(timings, 25)),
+                "speedup_vs_cpu_warm": 1.0 if method == "cpu_warm" else cpu_median / cuda_median,
+                "speedup_ci_low": 1.0 if method == "cpu_warm" or ci is None else ci[0],
+                "speedup_ci_high": 1.0 if method == "cpu_warm" or ci is None else ci[1],
+                "torch_slowdown": 1.0 if method == "cpu_warm" else slowdown,
+                "performance_gate": (
+                    "baseline" if method == "cpu_warm" else "pass" if passed else "fail"
+                ),
+                "equivalent_to_cpu": True if method == "cpu_warm" else equivalent,
+                **data["metrics"],
+                **trace,
+            }
+            rows.append(row)
+    args.gate_failed = gate_failed
+    return rows
+
+
+def export_rows(rows, args):
+    if args.export_md:
+        path = Path(args.export_md)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(markdown_table(rows, RESULT_COLUMNS) + "\n", encoding="utf-8")
+    if args.export_csv:
+        path = Path(args.export_csv)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=RESULT_COLUMNS)
+            writer.writeheader()
+            writer.writerows({key: row[key] for key in RESULT_COLUMNS} for row in rows)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+    rows = benchmark(args)
+    print(markdown_table(rows, RESULT_COLUMNS))
+    export_rows(rows, args)
+    if args.enforce_gate and args.gate_failed:
+        raise SystemExit(
+            "Torch CUDA exceeded the end-to-end correctness/performance gate."
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md b/docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
new file mode 100644
index 0000000..a2097c6
--- /dev/null
+++ b/docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
@@ -0,0 +1,806 @@
+# Full Development and Validation Pipeline
+
+Version: 2.2
+Date: 2026-07-04
+Status: Release-candidate specification and roadmap; accelerator promotion gated
+
+## Part I - Executive Summary
+
+### 1. Decision
+
+Build a correctness-first, Torch-native OSQP reference route for PyGRANSO.
+The implementation is dense and uses PyTorch's built-in LU factorization. It
+is not presented as a sparse large-scale solver. Sparse acceleration is a
+future backend that must fit behind the same internal interface.
+
+The first trustworthy milestone supports feasible convex QPs and is judged by
+observable outcomes: compatible status, feasibility, stationarity, residuals,
+and objective. It does not require identical ADMM trajectories or iteration
+counts across devices or backends.
+
+### 2. Primary acceptance envelope
+
+| Item | Supported contract |
+| --- | --- |
+| Problem class | Feasible convex QPs in OSQP form |
+| Authoritative precision | float64 |
+| Qualified precision | float32 with looser tolerances and KKT conditioning approximately 1e2 |
+| Automatic dense limit | KKT dimension n + m <= 2400 |
+| Float64 supported conditioning | Approximately 1e8 |
+| Stress-only conditioning | Approximately 1e10 |
+| Linear algebra | Reusable torch.linalg.lu_factor_ex and lu_solve |
+| Required features | Ruiz scaling, adaptive rho, polishing, warm starts |
+| Default CPU policy | Builtin OSQP |
+| Default accelerator policy | Torch only after that backend passes its gates |
+| Failure budget | Zero unexplained failures inside the supported matrix |
+
+### 3. Backend support matrix
+
+| Backend | Precision | Initial status | Promotion evidence |
+| --- | --- | --- | --- |
+| Torch CPU on Linux | float32/float64 | Release-gated | Core, nightly, end-to-end |
+| Torch CPU on Windows | float32/float64 | Local correctness pass; release-gated | Cross-version CI still required |
+| Torch CPU on macOS | float32/float64 | Release-gated | Core, nightly, end-to-end |
+| NVIDIA CUDA | float32/float64 | Unpromoted | Earlier local correctness evidence passed, but current-source full CUDA reruns on the GTX 1650 exceeded the two-hour local wrapper and 12.48x, 21.33x, and 43.46x end-to-end slowdowns failed the <=5x gate |
+| AMD ROCm | float32/float64 | Unclaimed | Real-hardware runner required |
+| Apple MPS | float32 only | Unclaimed | Reusable LU must pass on real Apple hardware |
+| Apple MPS float64 | Unsupported | Builtin CPU result under auto | MPS does not support float64 tensors |
+
+### 4. Outcome
+
+The default `auto` policy follows the requested optimization device. CPU work
+uses builtin OSQP. Accelerator work uses Torch only when the device, KKT size,
+memory estimate, correctness suite, and performance sanity gate are all
+satisfied. Any automatic Torch exception or unsolved status produces a visible
+builtin fallback and a complete causal record. Explicit Torch requests never
+change backend silently.
+
+### 5. Main risks and controls
+
+| Risk | Control |
+| --- | --- |
+| Repeated dense refactorization | Cache LU and refactor only when the KKT matrix changes |
+| Dense memory growth | n + m limit plus conservative working-memory preflight |
+| Float32 stagnation | Dtype-aware 1e-5 defaults and condition-aware classification |
+| Hidden CPU fallback | Warning plus structured backend, trigger, transfer, and result fields |
+| Cross-run state contamination | One private workspace per BFGS-SQP run |
+| Misclassified infeasibility | Do not claim certificates in the first milestone |
+| Optional polishing corrupts a valid result | Accept only nonworse KKT metrics; numerical failure raises |
+| Unsupported accelerator claims | Promote each backend only after real-hardware evidence |
+
+<!-- PAGEBREAK -->
+
+## Part II - Decision-Complete Engineering Specification
+
+### 6. Architecture
+
+```text
+PyGRANSO BFGS-SQP
+  -> steering QP or stationarity QP
+  -> solveQP.py
+  -> osqpTorchAdapter.py
+  -> canonical P, q, A, l, u
+     -> builtin CPU OSQP
+     -> dense Torch OSQP reference
+        -> OSQP ADMM equations
+        -> private DenseLUSolver boundary
+        -> PyTorch LU factorization and repeated solves
+```
+
+The linear-solver boundary is internal. The user selects only
+`osqp_algebra={auto,builtin,torch}`. No nested linear-solver selector is
+exposed until a second validated Torch backend exists.
+
+### 7. Milestone roadmap
+
+This roadmap is the work-breakdown view of the specification. Each phase is
+complete only when its interface, data structures, tests, and evidence artifacts
+are all present. The roadmap intentionally keeps solver correctness ahead of
+performance and moves certificate/nonconvex/sparse claims to later work.
+
+The decision-complete release checklist and per-phase implementation plans live
+under `docs/plans/`, with `docs/plans/roadmap.md` as the status source for
+checked and unchecked release-readiness tasks.
+
+#### Phase 0 - Research snapshot and rollback point
+
+Goal: preserve the prior sparse-CG/CUDA Graph research state before narrowing
+the main package path to the dense reference route.
+
+Inputs:
+
+- current sparse-CG, sparse-operator, Jacobi, and CUDA Graph research code;
+- old benchmarks, tests, notebooks, documentation, and local evidence;
+- current git branch and release candidate worktree.
+
+Outputs:
+
+- archive branch `archive/sparse-cg-cuda-graph`;
+- signed tag `research-sparse-cg-cuda-graph-final`;
+- baseline validation result for the archived snapshot;
+- main branch with research execution removed from the active package path.
+
+Data structures and artifacts:
+
+- git branch/tag objects are the durable archive handles;
+- archived tests and benchmark files remain available only through the archive;
+- `.codex/code-edit-log.md` records the baseline and migration decision.
+
+Functions and commands:
+
+- `git branch`, `git tag`, `git push`;
+- package-path deletion of custom CG, sparse operator, Jacobi, and CUDA Graph
+  selection code.
+
+Validation:
+
+- verify archive branch and tag resolve to the intended commit;
+- verify active package imports no removed research solver path;
+- record baseline test status before removal.
+
+Exit criteria:
+
+- a reviewer can recover the research snapshot from git;
+- the active route contains no hidden sparse-CG/CUDA Graph execution path.
+
+#### Phase 1 - Public QP contract and backend policy
+
+Goal: define the public behavior before implementing the dense reference
+internals.
+
+Inputs:
+
+- PyGRANSO QP arguments `H`, `f`, `A`, `b`, `LB`, `UB`;
+- requested `torch_device`;
+- `double_precision`;
+- `osqp_options` containing `algebra`, `settings`, and `workspace`.
+
+Outputs:
+
+- canonical OSQP problem `P`, `q`, `A_osqp`, `l`, `u`;
+- backend selection result: `builtin` or `torch`;
+- result tensor on the requested or documented fallback device;
+- structured `info` dictionary when `return_info=True`.
+
+Data structures:
+
+- `DEFAULT_OSQP_SETTINGS` is the common settings source;
+- `PROMOTED_ACCELERATOR_BACKENDS` controls automatic accelerator eligibility;
+- fallback telemetry is stored in `info["fallback"]`;
+- backend cache state is stored in `TorchOSQPWorkspace`.
+
+Functions:
+
+- `solveQP(...)` is the PyGRANSO QP entry point;
+- `_solve_osqp_with_warm_state(...)` injects per-run workspace state;
+- `solve_osqp_torch_qp(...)` owns public OSQP backend selection;
+- `_select_backend(...)` applies `auto`, `builtin`, and `torch` policy;
+- `_build_constraints_torch(...)` and `_build_constraints_numpy(...)` create
+  canonical OSQP rows.
+
+Validation:
+
+- accepted `osqp_algebra` values are exactly `auto`, `builtin`, and `torch`;
+- CPU `auto` uses builtin OSQP;
+- unpromoted or unsupported accelerator `auto` falls back with warning and
+  telemetry;
+- explicit `torch` never changes backend silently.
+
+Exit criteria:
+
+- public behavior is stable before inner solver work begins;
+- unsupported options fail with actionable migration errors.
+
+#### Phase 2.1 - Data model, workspace, and factorization lifecycle
+
+Goal: make reusable state explicit, private, and safe across repeated QP solves.
+This is the primary data-structure milestone.
+
+Primary data structures:
+
+- `TorchOSQPWorkspace`
+  - Owner: one `AlgBFGSSQP` run.
+  - Input role: passed as `osqp_options["workspace"]`.
+  - Output role: records warm state, solver factors, backend cache, and latest
+    diagnostics.
+  - Warm-state fields: `state["x"]`, `state["z"]`, `state["y"]`.
+  - Structure fields: `problem_signature`, `constraint_order_signature`,
+    `p_pattern`, `a_pattern`.
+  - Scaling fields: `scaling`, `scaling_source_p`, `scaling_source_a`,
+    `scaling_passes`.
+  - Rho fields: `rho_bar`, `rho_setting`.
+  - Backend fields: `active_backend`, `builtin_cache`, `builtin_stats`.
+  - Solver field: `linear_solver`, an owned `DenseLUSolver`.
+  - Diagnostic field: `last_info`.
+- `DenseLUSolver`
+  - Owner: `TorchOSQPWorkspace.linear_solver`.
+  - Input role: receives dense KKT matrix `K` and finite RHS tensors.
+  - Output role: returns solution tensors and `LinearSolveDiagnostics`.
+  - Cached fields: matrix clone, LU factors, pivots, factorization status.
+  - Counters: `factorization_count`, `solve_count`.
+- `LinearSolveDiagnostics`
+  - Owner: emitted per linear solve.
+  - Fields: solver name, LU info, factorization count, solve count, optional
+    absolute and relative linear residuals.
+
+Workspace input/output contract:
+
+| Operation | Input | Preserved output | Invalidated output |
+| --- | --- | --- | --- |
+| Vector-only update | same P/A values and structure, new q/l/u | x, z, y, rho, scaling, LU | none |
+| Matrix-value update | same P/A shape, pattern, dtype, device, order | x, z, y | scaling and LU |
+| Rho or sigma change | compatible problem, changed setting | x, z, y | LU |
+| Dimension/order/structure change | changed shape, pattern, or constraint order | none | x, z, y, scaling, LU |
+| Dtype/device/backend change | changed dtype, device, or selected backend | none | complete workspace |
+
+Function contracts:
+
+| Function | Input | Output | Failure mode |
+| --- | --- | --- | --- |
+| `TorchOSQPWorkspace.ensure_backend(backend)` | `"builtin"` or `"torch"` | boolean backend-change flag | `ValueError` for unknown backend |
+| `TorchOSQPWorkspace.reset_torch()` | none | clears Torch warm state, scaling, rho, LU, diagnostics | none |
+| `DenseLUSolver.factorize(K)` | square finite strided float32/float64 tensor | cached LU/pivots and incremented factorization count | `TorchLinearSolveError` or validation error |
+| `DenseLUSolver.solve(rhs)` | finite vector or matrix RHS matching K | solution with vector shape restored plus diagnostics | `TorchLinearSolveError` or validation error |
+| `DenseLUSolver.factorize_if_needed(K)` | candidate KKT matrix | `True` when factorized, `False` when reused | same as `factorize` |
+| `_prepare_workspace(workspace, P, A, order)` | workspace plus canonical matrices | compatible state preserved or reset deterministically | none for valid inputs |
+
+Validation:
+
+- unit-test RHS vector normalization and matrix RHS solves;
+- reject nonfinite matrices/RHS values before LU/solve;
+- check LU `info` and nonfinite factors/solutions;
+- prove factorization reuse for vector-only updates;
+- prove refactorization for matrix-value, rho, or sigma updates;
+- prove complete invalidation for structure/order/dtype/device/backend changes.
+
+Exit criteria:
+
+- no module global stores Torch OSQP warm state or factors;
+- every reusable object has one owner and one invalidation policy;
+- diagnostics can explain whether factors were reused, rebuilt, or cleared.
+
+#### Phase 2.2 - Dense Torch ADMM kernel
+
+Goal: implement the direct dense reference solver around the Phase 2.1
+factorization boundary while preserving the OSQP equations.
+
+Inputs:
+
+- validated `P`, `q`, `A`, `l`, `u`;
+- normalized settings;
+- compatible `TorchOSQPWorkspace`.
+
+Outputs:
+
+- solution tensor `x` shaped `(n, 1)`;
+- updated workspace state `x`, `z`, `y`;
+- `info` with status, residuals, objective, iterations, rho, scaling, and
+  factorization counters.
+
+Data structures:
+
+- dense KKT matrix `K`;
+- ADMM vectors `x`, `z`, `y`, `x_tilde`, `z_tilde`, `nu`;
+- vector-valued `rho_vec`, with equality rows boosted.
+
+Functions:
+
+- `build_kkt_matrix(P, A, sigma, rho_vec)`;
+- `build_kkt_rhs(x, z, y, q, sigma, rho_vec)`;
+- `recover_z_tilde(z, nu, y, rho_vec)`;
+- `admm_vector_update(...)`;
+- `solve_torch_osqp_direct(...)`.
+
+Validation:
+
+- KKT block assembly and RHS tests;
+- projection and dual-update equation tests;
+- finite solution and residual checks;
+- solved/max-iteration status handling only.
+
+Exit criteria:
+
+- mathematical equations match the specification;
+- numerical failures are raised or reported as unsolved, never as infeasibility.
+
+#### Phase 2.3 - Scaling, adaptive rho, polishing, and warm starts
+
+Goal: add the numerical features required for observable OSQP agreement without
+changing the public backend contract.
+
+Inputs:
+
+- Phase 2.2 dense direct solve;
+- settings for scaling, adaptive rho, polishing, and warm start;
+- existing workspace state when compatible.
+
+Outputs:
+
+- scaled solve whose accepted residuals/objective are reported in original
+  coordinates;
+- deterministic rho updates and refactorized KKT matrices;
+- accepted polished solution or explicit polishing failure;
+- reusable warm state for the next compatible solve.
+
+Data structures:
+
+- Ruiz scaling dictionary: `D`, `E`, `cost`, `passes`;
+- original-coordinate state dictionary: `x`, `z`, `y`;
+- polishing active-set rows and active RHS;
+- polishing info fields in `info`.
+
+Functions:
+
+- `_scaling_for_problem(...)`;
+- `_scale_problem(...)`;
+- `_initial_scaled_state(...)`;
+- `_unscale_state(...)`;
+- `_adaptive_rho_update(...)`;
+- `_polish_solution(...)`;
+- `_residuals(...)`.
+
+Validation:
+
+- scaling round-trip tests;
+- deterministic adaptive-rho tests;
+- polishing active-row and duplicate-row tests;
+- warm-start reuse and invalidation tests.
+
+Exit criteria:
+
+- every residual and objective used for acceptance is in original coordinates;
+- polishing cannot silently degrade an accepted result;
+- compatible warm starts are observable through diagnostics.
+
+#### Phase 3 - Builtin parity, fallback, and public telemetry
+
+Goal: make builtin OSQP and Torch OSQP comparable through one adapter contract.
+
+Inputs:
+
+- PyGRANSO QP form;
+- selected backend;
+- normalized common settings;
+- per-run workspace.
+
+Outputs:
+
+- builtin or Torch solution tensor;
+- common residual/objective metrics;
+- backend/fallback telemetry;
+- builtin workspace setup/update counters.
+
+Data structures:
+
+- builtin OSQP cache with sparse `P`, sparse `A`, OSQP problem, and last result;
+- `builtin_stats` with setup, update, rebuild, and cache-hit counts;
+- `info["fallback"]` with trigger, selected backend, fallback backend, status
+  or exception, and device-transfer flag.
+
+Functions:
+
+- `_solve_builtin_osqp_path(...)`;
+- `_builtin_common_metrics(...)`;
+- `_dense_polish_builtin(...)`;
+- `_selection_fallback(...)`;
+- `_accelerator_capability(...)`;
+- `_builtin_result_device(...)`.
+
+Validation:
+
+- builtin cache reuse for structurally compatible updates;
+- auto Torch exception fallback;
+- auto unsolved-status fallback;
+- memory and size fallback;
+- MPS float64 CPU-result behavior.
+
+Exit criteria:
+
+- automatic fallback is always visible;
+- explicit Torch failures remain explicit;
+- builtin and Torch comparisons use shared metrics rather than raw iterates.
+
+#### Phase 4 - Validation evidence pipeline
+
+Goal: prove the solver behavior through deterministic, differential,
+metamorphic, randomized, end-to-end, and platform gates.
+
+Inputs:
+
+- unit tests under `tests/`;
+- fixed randomized seeds;
+- backend/device/dtype matrix;
+- PyGRANSO B1/B2/B3 workloads.
+
+Outputs:
+
+- passing deterministic core test result;
+- nightly 100-seed evidence per family/backend bucket;
+- serialized reproduction data for each failure;
+- release-gate status for each supported backend.
+
+Data structures and artifacts:
+
+- `torch_osqp_stability_results.csv`;
+- `torch_osqp_stability_manifest.json`;
+- `torch_osqp_stability_summary.md`;
+- failure reproduction `.pt` files;
+- GitHub Actions artifacts for core, nightly, and CUDA promotion workflows.
+
+Functions and scripts:
+
+- `torch_osqp_stability.py`;
+- `bench_osqp_dense_reference.py`;
+- `bench_pygranso_osqp_workloads.py`;
+- `.github/workflows/torch-osqp-core.yml`;
+- `.github/workflows/torch-osqp-nightly.yml`;
+- `.github/workflows/torch-osqp-cuda-promotion.yml`.
+
+Validation:
+
+- deterministic pytest suite on every change;
+- nightly fixed-seed CPU stability buckets;
+- self-hosted real-hardware accelerator promotion buckets;
+- benchmark gate for automatic accelerator promotion.
+
+Exit criteria:
+
+- zero unexplained failures inside the supported size, dtype, conditioning, and
+  backend matrix;
+- stress rows are classified as stress evidence, not as support claims.
+
+#### Phase 5 - Backend promotion
+
+Goal: turn backend support on only after backend-specific evidence exists.
+
+Inputs:
+
+- Phase 4 evidence package;
+- real hardware for each claimed accelerator;
+- performance gate output.
+
+Outputs:
+
+- updated backend support matrix;
+- promoted/unpromoted accelerator decision;
+- public `auto` behavior aligned with the support matrix.
+
+Data structures:
+
+- `PROMOTED_ACCELERATOR_BACKENDS`;
+- support matrix in this document;
+- release evidence manifests.
+
+Functions:
+
+- `_accelerator_capability(...)`;
+- `_select_backend(...)`;
+- `bench_pygranso_osqp_workloads.py`.
+
+Validation:
+
+- CPU support gates on Linux, Windows, and macOS;
+- CUDA correctness, stress, and no-worse-than-5x end-to-end median runtime;
+- ROCm and MPS remain unclaimed until real runners exist.
+
+Exit criteria:
+
+- no backend is promoted by assumption;
+- `auto` routes only to backends with current evidence.
+
+#### Phase 6 - Documentation, PDF, and release handoff
+
+Goal: make the implementation reviewable and reproducible.
+
+Inputs:
+
+- final code, tests, workflows, and evidence;
+- this Markdown specification;
+- completion audit.
+
+Outputs:
+
+- maintained Markdown specification;
+- decision-complete `docs/plans` roadmap and phase plans;
+- rendered PDF;
+- completion audit;
+- code-edit report entries;
+- release tracking report under `F:\UMN Researches\Ju Research\Report`;
+- release PR notes.
+
+Data structures and artifacts:
+
+- `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`;
+- `docs/TORCH_OSQP_COMPLETION_AUDIT.md`;
+- `docs/plans/roadmap.md` and linked phase plans;
+- `output/pdf/Full Development and Validation Pipeline - Revised.pdf`;
+- `.codex/code-edit-log.md`.
+
+Functions and scripts:
+
+- `scripts/render_pipeline_pdf.py`;
+- git/CI evidence inspection commands.
+
+Validation:
+
+- Markdown headings and code blocks render cleanly;
+- PDF includes table of contents, support matrix, risk table, roadmap,
+  decision log, and controlled page breaks;
+- audit status matches current source and evidence.
+
+Exit criteria:
+
+- a reviewer can follow the roadmap from public API to data model to validation
+  evidence without reading implementation code first.
+
+### 8. Canonical QP contract
+
+Solve:
+
+```text
+minimize    0.5 * x' P x + q' x
+subject to  l <= A x <= u
+```
+
+Requirements:
+
+- P is square, finite, and positive semidefinite within the supported numerical envelope.
+- q and A are finite.
+- l and u may contain infinity but never NaN, and l <= u elementwise.
+- All Torch inputs use the same device and dtype after adapter normalization.
+- Only float32 and float64 are supported.
+- Near-symmetric P is replaced by 0.5 * (P + P.T) only when its infinity-norm asymmetry is within a dtype-aware tolerance.
+- A diagnostic eigenvalue check is available for tests and debugging; it is not paid on every solve.
+
+### 9. Dense linear-solver lifecycle
+
+The private solver owns the matrix and its LU factors.
+
+```text
+factorize(K)
+  validate square, dtype, device, and finite values
+  call torch.linalg.lu_factor_ex(K, check_errors=False)
+  reject nonzero info or non-finite factors
+
+solve(rhs)
+  normalize a vector RHS to shape (n, 1)
+  validate shape, dtype, device, and finite values
+  call torch.linalg.lu_solve(LU, pivots, rhs)
+  reject non-finite solutions
+  optionally report ||Kx-b|| / max(1, ||b||)
+
+refactorize(K)
+  run only after P, A, rho, sigma, dtype, or device changes
+```
+
+Reuse the same factorization across ADMM iterations and across compatible
+updates to q, l, and u. A change to P or A values refactorizes. A change to
+dimensions, sparsity pattern, constraint ordering, dtype, device, or backend
+invalidates the complete workspace.
+
+### 10. Optimizer-owned workspace
+
+Each BFGS-SQP run owns one private `TorchOSQPWorkspace`. It stores:
+
+- original-coordinate x, z, and y warm state;
+- problem and structure signatures;
+- cached scaling vectors and cost scale;
+- the latest adaptive rho value;
+- the dense LU solver and counters;
+- the builtin OSQP update workspace;
+- the last structured diagnostics.
+
+Independent, nested, or concurrent PyGRANSO runs never share warm state or
+factorizations through module globals.
+
+### 11. Preserved OSQP equations
+
+The direct KKT system is:
+
+```text
+[ P + sigma I    A'          ] [x_tilde] = [sigma x - q]
+[ A             -diag(rho)^-1] [nu     ]   [z - y/rho ]
+```
+
+Recover and update:
+
+```text
+z_tilde = z + (nu - y) / rho
+x_next = alpha * x_tilde + (1-alpha) * x
+z_relaxed = alpha * z_tilde + (1-alpha) * z
+z_next = project_[l,u](z_relaxed + y/rho)
+y_next = y + rho * (z_relaxed - z_next)
+```
+
+Stopping residuals are evaluated in original coordinates:
+
+```text
+r_primal = ||A x - z||_inf
+r_dual   = ||P x + q + A' y||_inf
+```
+
+Nonunique problems are accepted by feasibility, stationarity, objective, and
+compatible status rather than by matching x exactly.
+
+### 12. Required numerical features
+
+#### 12.1 Ruiz scaling
+
+Use ten deterministic diagonal-equilibration passes, solve the scaled problem,
+then unscale x, z, and y. Reuse cached scaling for vector-only parametric
+updates. All acceptance residuals and objectives are reported in original
+coordinates.
+
+#### 12.2 Adaptive rho
+
+Use a deterministic interval of 50 and an update tolerance of 5. Equality rows
+receive the larger vector-valued rho policy. Every accepted rho change rebuilds
+and refactorizes K while continuing from the current x, z, and y.
+
+<!-- PAGEBREAK -->
+
+#### 12.3 Polishing
+
+Build the active-set polishing KKT system through the same LU boundary. Reuse
+the factorization for refinement steps. A candidate is accepted only when its
+KKT metric is no worse or it satisfies the target tolerances. A factorization,
+refinement, or candidate-acceptance failure raises when polishing was requested.
+
+#### 12.4 Warm starts
+
+Warm starts are enabled internally. Compatible vector updates reuse x, z, y,
+rho, scaling, and LU. Matrix-value updates retain x, z, and y but recompute
+scaling and factors. Structural changes clear the workspace.
+
+### 13. Defaults
+
+| Setting | Default |
+| --- | ---: |
+| rho | 0.1 |
+| sigma | 1e-6 |
+| alpha | 1.6 |
+| max_iter | 4000 |
+| check_termination | 25 |
+| float64 eps_abs and eps_rel | 1e-8 |
+| float32 eps_abs and eps_rel | 1e-5 |
+| scaling | 10 |
+| adaptive_rho | true |
+| rho_update_interval | 50 |
+| rho_update_tolerance | 5 |
+| polishing | true |
+| polish_delta | 1e-6 |
+| polish_refine_iter | 3 |
+| warm_start | true |
+
+### 14. Backend selection and fallback
+
+| Request | Behavior |
+| --- | --- |
+| auto on CPU | Builtin CPU OSQP |
+| auto on validated accelerator inside limits | Torch reference route |
+| auto on unsupported accelerator | Warn and use builtin |
+| auto above size or memory envelope | Warn and use builtin |
+| auto Torch exception or unsolved status | Warn, retry builtin, retain causal telemetry |
+| explicit builtin | Builtin CPU OSQP and return on requested device |
+| explicit torch inside limits | Torch reference route |
+| explicit torch above limits | Warn and attempt; never silently change backend |
+
+Fallback diagnostics include the requested and selected backends, the original
+exception or status, the fallback backend and outcome, and whether data moved
+between accelerator and CPU.
+
+### 15. Status and error semantics
+
+- Return structured statuses for solved and maximum-iteration outcomes.
+- Raise for invalid inputs, unsupported explicit operations, LU failure, NaN or Inf, and numerical polishing failure.
+- Under auto, any unsolved-compatible Torch status is eligible for a warned builtin retry.
+- An explicit Torch failure propagates to PyGRANSO's steering or stationarity fallback contract without being rewritten as a secondary unpacking or unbound-variable error.
+- Never label a linear solve failure as infeasibility.
+- Move primal and dual infeasibility certificates and nonconvex detection to a future milestone.
+
+### 16. Validation pipeline
+
+```text
+Dense LU unit tests
+  -> KKT assembly and ADMM equation tests
+  -> deterministic complete-QP tests
+  -> scaling, adaptive-rho, polishing, and warm-state tests
+  -> matched-setting builtin-vs-Torch differential tests
+  -> PyGRANSO steering and stationarity contracts
+  -> metamorphic tests
+  -> seeded randomized and conditioning tests
+  -> B1/B2/B3 and constrained end-to-end runs
+  -> backend-specific hardware gates
+  -> performance sanity gate
+```
+
+Core CI runs deterministic cases on every change. Nightly validation runs 100
+fixed seeds per family and backend bucket with a two-hour budget. Every failure
+records the complete QP, seed, settings, environment, results, and residuals.
+
+Inside the supported matrix, the failure budget is zero unexplained failures.
+Cases near condition number 1e10 are classified as stress evidence rather than
+as guaranteed support.
+
+### 17. Evidence package
+
+Each stability run produces:
+
+- `torch_osqp_stability_results.csv` with case-level gates;
+- `torch_osqp_stability_manifest.json` with commit, platform, hardware, Python, PyTorch, OSQP, backend, settings, and seeds;
+- `torch_osqp_stability_summary.md` with family totals;
+- one serialized reproduction file for every failure.
+
+If the wall-clock budget is exceeded after a case completes, the run still
+writes the CSV, manifest, summary, and any failure reproductions collected so
+far, marks `timed_out=true` and `partial_results=true` in the manifest, records
+the last completed case, and exits nonzero. A timed-out bucket is not passing
+release evidence, but it remains reproducible telemetry instead of a silent
+artifact loss.
+
+The manifest captures Git provenance before creating its own output directory,
+so `git_dirty` describes source state rather than generated evidence files. It
+also records status entries and a deterministic SHA-256 over maintained source,
+tests, workflows, scripts, and documentation, making dirty-worktree evidence
+exactly identifiable before a release commit exists.
+
+Stability reports estimate conditioning with a deterministic dense CPU KKT
+diagnostic using the initial common `rho` and `sigma` settings. The QP solves
+still execute on the requested backend, but the condition estimate itself does
+not call accelerator SVD/condition kernels; this keeps nightly and hardware
+evidence buckets inside the two-hour gate.
+
+Differential tests use identical algorithm settings. They compare status,
+primal and dual residuals, objective, equality violation, bound violation, and
+finite values. Objective gaps use `abs(torch-reference) / max(1, abs(reference))`.
+
+### 18. Performance gate
+
+Performance is not a correctness criterion. It controls only automatic backend
+promotion. On representative accelerator-targeted PyGRANSO workloads, the
+Torch median end-to-end time, including necessary transfers, must be no worse
+than five times builtin CPU OSQP. A backend that fails remains explicit or
+unclaimed even when its correctness suite passes.
+
+Current CUDA promotion evidence is intentionally insufficient. Earlier local
+NVIDIA correctness buckets passed, and a current-source CUDA float64 smoke
+passes, but current-source 100-seed CUDA float64 reruns on the local GTX 1650
+exceeded the two-hour wrapper. Independent end-to-end B1, B2, and B3 medians
+were 12.48x, 21.33x, and 43.46x the builtin CPU median respectively. CUDA
+therefore remains explicit-only and `auto` records a warned
+`cuda_not_promoted` builtin fallback.
+
+### 19. Migration sequence
+
+1. Validate and preserve the sparse-CG/CUDA Graph research snapshot.
+2. Create and push archive branch `archive/sparse-cg-cuda-graph`.
+3. Create and push signed tag `research-sparse-cg-cuda-graph-final`.
+4. Remove custom CG, Jacobi, sparse-operator, CUDA Graph, and selection code from the package path.
+5. Add DenseLUSolver and optimizer-owned workspace tests.
+6. Refactor direct ADMM around reusable LU.
+7. Validate scaling, adaptive rho, polishing, and warm starts.
+8. Implement the backend policy, migration errors, size guards, and fallback telemetry.
+9. Add differential, randomized, hardware, PyGRANSO, and reporting gates.
+10. Promote each backend only after its own correctness and performance evidence passes.
+
+### 20. Decision log
+
+| Decision | Rationale |
+| --- | --- |
+| Dense reference first | Correctness and maintainability are the primary objective |
+| Reusable LU instead of solve per iteration | Preserves built-in numerical ownership without repeated refactorization |
+| Observable OSQP agreement | Different devices and factorizations need not match trajectories |
+| Float64 authoritative | Float32 degrades materially on ill-conditioned KKT systems |
+| Feasible convex scope first | Prevents unvalidated certificate claims |
+| Auto follows requested device | Avoids unprofitable CPU-to-accelerator transfers |
+| Per-run workspace | Prevents cross-run state contamination |
+| Backend-by-backend promotion | Support claims require real hardware |
+| Five-times performance ceiling | Prevents severe automatic regressions without making speed the success criterion |
+
+### 21. Future work
+
+After the dense reference route passes all applicable gates, a sparse direct or
+iterative backend may implement the same factorize/solve/refactorize contract.
+Candidates include cuDSS, torch-sla, future PyTorch sparse solvers, and batched
+GPU solvers. The ADMM, adapter, PyGRANSO integration, tests, and evidence schema
+must not change for a solver replacement.
diff --git a/docs/MIXED_PRECISION.md b/docs/MIXED_PRECISION.md
index bde2b07..2078ddf 100644
--- a/docs/MIXED_PRECISION.md
+++ b/docs/MIXED_PRECISION.md
@@ -9,7 +9,7 @@ This note describes what to expect when using **`torch.autocast`** (or other mix
 - **`opts.double_precision`** (default: `True`) sets the dtype for PyGRANSO's **internal** data:
   - Optimization variable `x`, BFGS/L-BFGS state, penalty function values and gradients, line-search state, etc.
   - With `double_precision=True` → `torch.float64`; with `False` → `torch.float32`.
-- The **QP solver** (OSQP/Gurobi) receives data after `.cpu().numpy()`; its precision is whatever dtype those tensors had (float32 or float64) before conversion.
+- The **QP solver** receives PyGRANSO QP data in the dtype selected by `opts.double_precision`. For the OSQP backend, CPU solves use OSQP's Python wrapper; `opts.osqp_algebra="auto"` tries the Torch GPU path when CUDA is available and falls back to CPU OSQP with a warning if that path fails.
 - So: PyGRANSO's **algorithm state** is always in a single dtype (float32 or float64). It does **not** by default run your model in float16 or mixed precision.
 
 ---
@@ -86,8 +86,12 @@ This note describes what to expect when using **`torch.autocast`** (or other mix
 
 ### 4. 🔧 QP and other internals
 
-- The QP subproblems are built from tensors that PyGRANSO has already created (in float32 or float64), then converted to NumPy on CPU. Autocast does **not** change how the QP is built or solved; it only affects the **user-facing** objective/constraint and their gradients. So:
-  - **No** mixed precision inside the QP solver itself.
+- The QP subproblems are built from tensors that PyGRANSO has already created (in float32 or float64). Autocast does **not** change how the QP is built or solved; it only affects the **user-facing** objective/constraint and their gradients. So:
+  - **No** autocast mixed precision inside the QP solver itself.
+  - The OSQP CPU backend may copy data to CPU for OSQP's Python API.
+  - `opts.osqp_algebra="auto"` follows `opts.torch_device`: CPU uses builtin OSQP and a validated accelerator uses the dense Torch reference route inside its KKT and memory envelope.
+  - The Torch QP path uses one reusable dense-LU backend. Archived sparse-CG and CUDA Graph settings now produce a migration error.
+  - Float64 is authoritative through estimated KKT conditioning around `1e8`. Float32 uses `1e-5` defaults and a conservative qualified conditioning envelope around `1e2`; harder float32 cases remain stress evidence. MPS is float32-only and remains unclaimed until real-hardware LU validation is available, while MPS float64 auto requests return a builtin CPU result.
   - Impact of autocast is **only** on the quality and cost of the function/gradient values that PyGRANSO feeds into the QP and the rest of the algorithm.
 
 ---
diff --git a/docs/TORCH_OSQP_COMPLETION_AUDIT.md b/docs/TORCH_OSQP_COMPLETION_AUDIT.md
new file mode 100644
index 0000000..0fa5897
--- /dev/null
+++ b/docs/TORCH_OSQP_COMPLETION_AUDIT.md
@@ -0,0 +1,97 @@
+# Torch-OSQP Completion Audit
+
+Date: 2026-07-04
+Scope: revised dense Torch reference pipeline and release gates
+
+This audit separates implemented behavior from local evidence and external
+release gates. A configured gate is not reported as passing until its runner
+has produced evidence.
+
+## Architecture and migration
+
+| Requirement | Authoritative evidence | Status |
+| --- | --- | --- |
+| Preserve research snapshot | Branch `archive/sparse-cg-cuda-graph` exists locally and on `origin` at commit `da142c1`; baseline 79-test result is recorded in the edit log | Implemented and pushed to origin |
+| Signed archive tag | Tag `research-sparse-cg-cuda-graph-final` verifies as a PGP-signed tag at `da142c1` with key `913CC0E29352B362D9116C59387554B041B0ACDD`; `origin` has tag object `d40a6e0` | Implemented and pushed to origin |
+| Remove research execution from active path | Legacy benchmark, presentation, old adapter test, custom CG, sparse operator, and CUDA Graph code absent from the feature branch; archive branch retains them | Implemented |
+| Dense private LU lifecycle | `torchLinearSolve.py` uses `lu_factor_ex`, `lu_solve`, finite/status checks, RHS normalization, reuse, and optional diagnostics | Implemented and unit tested |
+| Per-run state | `TorchOSQPWorkspace` is created by each `AlgBFGSSQP` and owns Torch/builtin state, signatures, scaling, factors, and diagnostics | Implemented and unit tested |
+| Invalidation contract | Structure, order signature, dimensions, dtype, device, and backend reset state; compatible value updates retain warm state and refactor | Implemented and unit tested |
+| Roadmap and Phase 2.1 data contract | `FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md` section 7 now maps each milestone to inputs, outputs, data structures, functions, validation, and exit criteria; Phase 2.1 details `TorchOSQPWorkspace`, `DenseLUSolver`, and `LinearSolveDiagnostics` | Implemented |
+
+## Numerical and public behavior
+
+| Requirement | Authoritative evidence | Status |
+| --- | --- | --- |
+| Preserve KKT/ADMM/projection/dual/residual equations | `torchOSQP.py` plus `test_torch_osqp_kkt.py` | Implemented |
+| Ruiz scaling, adaptive rho, warm starts, strict polishing | Feature tests and direct-solver tests | Implemented |
+| Public algebra set is exactly auto/builtin/torch | Adapter validation and policy tests | Implemented |
+| CPU auto policy | Builtin selection test | Implemented |
+| Explicit Torch never changes backend | Explicit unsolved/error tests | Implemented |
+| Auto selection and runtime fallback telemetry | Exception, unsolved-status, unsupported-device, memory, and CUDA policy tests | Implemented |
+| MPS float64 behavior | Synthetic hardware-independent test verifies builtin CPU float64 result | Implemented; MPS remains unclaimed |
+| Dense limit and memory preflight | `n + m <= 2400`, warning/attempt behavior, selection tests, benchmark envelope check | Implemented |
+| Common defaults | Adapter defaults and rendered specification | Implemented |
+| Validation and symmetry contract | Invalid shape/dtype/device/NaN/bounds/asymmetry tests and optional eigenvalue diagnostic | Implemented |
+| No false infeasibility claims | Torch status vocabulary is solved/max-iteration only; hard QP errors propagate to PyGRANSO fallback contracts | Implemented |
+
+Float64 is the authoritative path through estimated KKT conditioning around
+`1e8`. Float32 uses the requested `1e-5` tolerances but is qualified only near
+estimated KKT conditioning `1e2`. A diagnostic mixed-precision solve showed
+that casting solutions and duals back to float32 still violated stationarity
+tolerances in 7/10 cases at condition `1e4`, 9/10 at `1e6`, and 10/10 at
+`1e8`. Claiming the float64 envelope for returned float32 values would therefore
+be unsupported by the requested numerical contract.
+
+## Validation and evidence
+
+| Gate | Evidence | Status |
+| --- | --- | --- |
+| Deterministic/unit/differential/metamorphic/PyGRANSO | Local pytest suite | Passing locally |
+| Windows CPU float64 | Local manifest-backed evidence: 300 rows; 200 condition-qualified release-gate passes and 100 non-gating stress passes | Passing locally |
+| Windows CPU qualified float32 | Local manifest-backed evidence: 300 rows; 199 condition-qualified release-gate passes and 101 non-gating rows, including 100 expected stress failures | Passing locally |
+| NVIDIA CUDA float64 | Earlier 300-row correctness evidence passed at `02e24fb`; current-source smoke evidence passed 2 rows, but 100-seed local GTX 1650 reruns exceeded the two-hour wrapper | Unpromoted; full current CUDA gate requires representative hardware |
+| NVIDIA CUDA qualified float32 | Earlier supported-family correctness evidence passed 200 rows at `02e24fb`; full stress remained non-gating/unpromoted | Unpromoted; representative promotion gate still required |
+| NVIDIA CUDA performance | B1/B2/B3 end-to-end medians 12.48x, 21.33x, and 43.46x builtin CPU | Failed; backend unpromoted |
+| Linux/Windows/macOS CPU matrix | GitHub Actions run `28557162633` on branch `feature/torch-osqp-dense-reference`; fork `main` nightly run `28767699164` completed all Linux/Windows/macOS float32/float64 buckets | Passing on fork |
+| PyTorch 2.8 and current stable | Core workflow run `28557162633`, including Python 3.10-3.13 endpoints | Passing on origin fork |
+| Nightly 100-seed platform buckets | Fork `main` workflow run `28767699164`: 1800 total CPU cases, zero release-gate failures; float64 passed 900/900, float32 supported rows passed with 300 stress-only non-gating failures and reproduction files | Passing on fork; upstream default-branch registration still pending |
+| CUDA real-hardware promotion | Manual self-hosted correctness, stress, and 5x workflow exists on the feature branch; local GTX 1650 evidence is insufficient for promotion and 5x performance gate fails | Configured; CUDA remains unpromoted |
+| ROCm and Apple MPS | No real runner | Unclaimed by design |
+
+Every stability bucket writes a case CSV, environment/settings/seed manifest,
+Markdown summary, and one serialized QP per failure. Provenance is captured
+before output creation so the dirty flag describes source state. Each manifest
+records the exact commit, source hash, platform, settings, and seeds for its
+own run; the audit intentionally treats those manifests as the authoritative
+provenance rather than hard-coding a commit that would become stale after a
+documentation-only or renderer-only follow-up. Earlier CUDA correctness
+evidence remains useful regression evidence, but CUDA is not promoted until
+representative current-source hardware gates pass.
+Time-limit exits now write the same artifact set for completed cases, mark the
+manifest as `timed_out` and `partial_results`, record the last completed case,
+and exit nonzero so a bucket can fail without losing local telemetry.
+Conditioning is estimated by a deterministic dense CPU KKT diagnostic with the
+common initial `rho` and `sigma`; backend solves still run on the requested
+device, but the evidence gate does not spend accelerator time on diagnostic SVD
+kernels.
+
+## Documentation and reporting
+
+| Deliverable | Status |
+| --- | --- |
+| Two-part decision-complete Markdown specification | Implemented |
+| Roadmap-style milestone plan with clear data structures, inputs, outputs, functions, validation, and exit criteria | Implemented; `docs/plans/roadmap.md` is the checked/unchecked status source and links to the 14 phase plans |
+| Rendered PDF with TOC, support/risk tables, decision log, and controlled breaks | Implemented and visually inspected |
+| Dense benchmark and B1/B2/B3 performance gate | Implemented |
+| Code-edit log | Maintained at `.codex/code-edit-log.md` |
+| Release-readiness tracker | Maintained at `F:\UMN Researches\Ju Research\Report\2026-07-04_pygranso_torch_osqp_release_tracking.md` |
+
+## Remaining release actions (PR Deferred)
+
+1. Obtain upstream review/merge permission for PR `#63` (Deferred: Do not do PR until project is perfect).
+2. Merge/register the feature-branch-only nightly and CUDA workflows on upstream
+   `main` before relying on upstream schedules/dispatch (Deferred).
+3. Keep CUDA unpromoted until its representative end-to-end median is no worse
+   than 5x builtin CPU OSQP.
+4. Obtain ROCm and MPS runners before making either support claim.
diff --git a/docs/UNCONSTRAINED_AND_OSQP.md b/docs/UNCONSTRAINED_AND_OSQP.md
index 0dcf9c8..5746248 100644
--- a/docs/UNCONSTRAINED_AND_OSQP.md
+++ b/docs/UNCONSTRAINED_AND_OSQP.md
@@ -1,6 +1,7 @@
 # Unconstrained Problem Handling and OSQP in PyGRANSO
 
-Notes on how PyGRANSO handles unconstrained problems, how stationarity is computed, and practical implications for the QP solver (including when CUDA/OSQP helps or does not).
+Notes on how PyGRANSO handles unconstrained problems, how stationarity is
+computed, and how the dense Torch reference and builtin OSQP policies apply.
 
 ---
 
@@ -77,75 +78,31 @@ For unconstrained problems, PyGRANSO uses a **two-stage stationarity check**.
 
 ---
 
-## QP Size, CUDA OSQP, and Memory
-
-Given the above, the **QP dimension** fed to the QP solver is on the order of **`l`** (for unconstrained) or **`q + l + p`** in general, often in the **hundreds to low thousands** (e.g. ~1000), not the full variable dimension `n`.
-
-- **CUDA-based OSQP** is aimed at **large-scale** QPs where GPU parallelism pays off.
-- At **~1000 variables**, there is **virtually no timing benefit** from the CUDA algebra compared to the built-in (CPU) solver, and the GPU path can be **more memory intensive**.
-- So for typical PyGRANSO use (moderate `l`, QP size ~hundreds to ~1k), **CPU OSQP (`algebra="builtin"`) is appropriate**; enabling CUDA OSQP is unlikely to help and may use more memory.
-
----
-
-## OSQP Experiment: ~1000 Variables (CPU vs CUDA)
-
-Example run with **~1000 QP variables** (903 variables, 900 constraints). Timings are effectively the same between CPU and CUDA OSQP.
-
-**Run 1 (CUDA):**
-
-```
------------------------------------------------------------------
-           OSQP v1.0.0  -  Operator Splitting QP Solver
-              (c) The OSQP Developer Team
------------------------------------------------------------------
-problem:  variables n = 903, constraints m = 900
-          nnz(P) + nnz(A) = 1935
-settings: algebra = CUDA 12.5,
-          OSQPInt = 4 bytes, OSQPFloat = 4 bytes,
-          device = Tesla T4 (Compute capability 7.5),
-          linear system solver = CUDA Conjugate Gradient - Diagonal preconditioner,
-          eps_abs = 1.0e-03, eps_rel = 1.0e-03,
-          eps_prim_inf = 1.0e-15, eps_dual_inf = 1.0e-15,
-          rho = 1.00e-01 (adaptive: 50 iterations),
-          sigma = 1.00e-06, alpha = 1.60, max_iter = 1000000000
-          check_termination: on (interval 5, duality gap: off),
-          time_limit: 1.00e+03 sec,
-          scaling: on (10 iterations), scaled_termination: off
-          warm starting: on, polishing: off,
-Solving using OSQP with algebra=cuda (indirect)
-iter   objective    prim res   dual res   gap        rel kkt    rho         time
-   1  -9.5998e+03   1.64e+01   4.15e+00  -9.66e+03   1.64e+01   1.00e-01    2.02e-02s
- 110   1.1065e+02   8.89e-03   2.57e-04  -2.29e-01   8.89e-03   1.00e-01    2.07e-01s
-
-status:               solved
-number of iterations: 110
-optimal objective:    110.6477
-dual objective:       110.8764
-duality gap:          -2.2873e-01
-primal-dual integral: 1.6890e+04
-run time:             2.07e-01s
-optimal rho estimate: 1.46e-01
-```
-
-**Run 2 (CUDA, repeated):**
-
-```
------------------------------------------------------------------
-           OSQP v1.0.0  -  Operator Splitting QP Solver
-              (c) The OSQP Developer Team
------------------------------------------------------------------
-problem:  variables n = 903, constraints m = 900
-          nnz(P) + nnz(A) = 1935
-settings: algebra = CUDA 12.5,
-          ...
-Solving using OSQP with algebra=cuda (indirect)
-iter   objective    prim res   dual res   gap        rel kkt    rho         time
-   1  -9.5998e+03   1.64e+01   4.15e+00  -9.66e+03   1.64e+01   1.00e-01    1.74e-02s
- 110   1.1065e+02   7.81e-03   1.77e-04  -2.24e-01   7.81e-03   1.00e-01    2.07e-01s
-
-status:               solved
-run time:             2.08e-01s
-optimal rho estimate: 1.81e-01
-```
-
-**Conclusion:** At this problem size there is **virtually no difference in timing** between runs, and CPU OSQP is typically sufficient and less memory-intensive than CUDA for PyGRANSO’s QP subproblems.
+## QP Size, Dense Torch OSQP, and Memory
+
+The QP dimension is on the order of `l` for unconstrained stationarity checks
+or `q + l + p` in general. It is usually much smaller than the original model
+dimension, but can still reach the low thousands.
+
+- The Torch-direct route is a correctness-first **dense reference solver**, not
+  a scalable sparse solver.
+- `opts.osqp_algebra = "auto"` keeps CPU-targeted work on builtin OSQP and uses
+  Torch only for independently promoted accelerator backends.
+- `opts.osqp_algebra = "torch"` explicitly requests the dense Torch route.
+- Automatic Torch selection is limited to `n + m <= 2400` plus a conservative
+  dense-memory preflight. Explicit Torch requests above the envelope warn and
+  attempt the requested backend.
+- Torch reuses `torch.linalg.lu_factor_ex`/`lu_solve` factors and includes Ruiz
+  scaling, deterministic adaptive rho, strict polishing, and per-run warm state.
+- Automatic exceptions or unsolved statuses produce a warned builtin retry with
+  causal telemetry. MPS float64 requests return a builtin CPU float64 result.
+- Sparse-CG, Jacobi, sparse operators, and CUDA Graph execution exist only on
+  the research archive branch; their former settings produce a migration error.
+
+Local NVIDIA correctness evidence passed, but representative B1/B2/B3 runs
+were 12.48x, 21.33x, and 43.46x slower than builtin CPU OSQP. CUDA therefore
+remains unpromoted for `auto`. Sparse acceleration and performance-oriented
+backends are later milestones behind the same private factorization boundary.
+
+PyGRANSO does not differentiate through a QP solve. Autograd forms objective
+and constraint gradients before QP construction.
diff --git a/docs/plans/README.md b/docs/plans/README.md
new file mode 100644
index 0000000..d5aa47c
--- /dev/null
+++ b/docs/plans/README.md
@@ -0,0 +1,62 @@
+# Torch-OSQP Plans
+
+This directory contains tiny milestone plans for the current PyGRANSO
+Torch-OSQP dense reference project.
+
+The style follows `C:/Users/1/Downloads/phase_2.1_plan.md`: every file is a
+planning blueprint with existing assets, data-structure design, ASCII-style
+class/module details, implementation checkboxes, validation checkboxes, and exit
+criteria.
+The downloaded file is used only as a style model; its browser-extension content
+is intentionally ignored.
+
+No local `phase_2.1_plan.md` duplicate is created.
+
+## Roadmap
+
+- [roadmap.md](roadmap.md) — decision-complete roadmap with support envelope,
+  architecture, lifecycle contracts, evidence gates, and verified/pending
+  checkbox status.
+
+## Tiny milestone plans
+
+### Phase 0 — Research snapshot and active-path cleanup
+
+- [phase_0.1_archive_snapshot_plan.md](phase_0.1_archive_snapshot_plan.md)
+- [phase_0.2_remove_research_paths_plan.md](phase_0.2_remove_research_paths_plan.md)
+
+### Phase 1 — Public contract and adapter policy
+
+- [phase_1.1_public_qp_contract_plan.md](phase_1.1_public_qp_contract_plan.md)
+- [phase_1.2_backend_policy_and_fallback_plan.md](phase_1.2_backend_policy_and_fallback_plan.md)
+- [phase_1.3_settings_validation_and_migration_plan.md](phase_1.3_settings_validation_and_migration_plan.md)
+
+### Phase 2 — Dense Torch solver internals
+
+- [phase_2.1_dense_lu_workspace_plan.md](phase_2.1_dense_lu_workspace_plan.md)
+- [phase_2.2_direct_admm_kernel_plan.md](phase_2.2_direct_admm_kernel_plan.md)
+- [phase_2.3_scaling_adaptive_polishing_plan.md](phase_2.3_scaling_adaptive_polishing_plan.md)
+
+### Phase 3 — PyGRANSO integration and builtin parity
+
+- [phase_3.1_builtin_parity_plan.md](phase_3.1_builtin_parity_plan.md)
+- [phase_3.2_pygranso_integration_plan.md](phase_3.2_pygranso_integration_plan.md)
+
+### Phase 4 — Validation, evidence, and backend promotion
+
+- [phase_4.1_tests_and_differential_plan.md](phase_4.1_tests_and_differential_plan.md)
+- [phase_4.2_stability_evidence_plan.md](phase_4.2_stability_evidence_plan.md)
+- [phase_4.3_platform_promotion_plan.md](phase_4.3_platform_promotion_plan.md)
+
+### Phase 5 — Documentation and release handoff
+
+- [phase_5.1_documentation_pdf_release_plan.md](phase_5.1_documentation_pdf_release_plan.md)
+- [phase_5.2_fork_local_hardening_plan.md](phase_5.2_fork_local_hardening_plan.md)
+
+## Planning conventions
+
+- [x] Each plan uses current PyGRANSO/Torch-OSQP files and functions.
+- [x] Each plan includes UML-style class diagrams for every class/data holder it names.
+- [x] Each plan breaks work into small checkboxes.
+- [x] Each plan separates implementation, validation, and exit criteria.
+- [x] Plans describe future/review work and must not overclaim support evidence.
diff --git a/docs/plans/phase_0.1_archive_snapshot_plan.md b/docs/plans/phase_0.1_archive_snapshot_plan.md
new file mode 100644
index 0000000..65bdac0
--- /dev/null
+++ b/docs/plans/phase_0.1_archive_snapshot_plan.md
@@ -0,0 +1,282 @@
+# Phase 0.1 Implementation Plan: Research Snapshot Archive
+
+## Goal
+
+Implement **research snapshot archive verification**.
+
+This feature should allow the project to:
+
+1. Prove the sparse-CG/CUDA Graph research line is recoverable.
+2. Record branch, tag, signature, and baseline validation evidence.
+3. Let mainline dense Torch-OSQP work proceed without losing prior research.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: records archive branch and tag evidence.
+* `.codex/code-edit-log.md`: records work-session evidence and baseline notes.
+* Git refs: expected archive branch `archive/sparse-cg-cuda-graph` and tag `research-sparse-cg-cuda-graph-final`.
+
+The missing part is:
+
+* A standalone checklist plan for verifying the archive evidence.
+* A clear data model for archive proof records.
+* A repeatable validation workflow for future auditors.
+
+---
+
+## New Components to Add
+
+Add the following planning components.
+
+### Component 1
+
+```text
+ArchiveEvidenceRecord
+```
+
+Responsibility:
+
+```text
+Track branch, tag, baseline validation, and recovery instructions as one reviewable archive proof.
+```
+
+### Component 2
+
+```text
+GitRefVerifier
+```
+
+Responsibility:
+
+```text
+Verify local and remote refs resolve to the expected archive commit and expose clear failure messages.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Archive Evidence Record
+
+```text
++-------------------------------------------------------------------------------+
+|                              ArchiveEvidenceRecord                             |
++-------------------------------------------------------------------------------+
+|  - archiveBranch: string                                                       |
+|  - archiveTag: string                                                          |
+|  - expectedCommit: string                                                      |
+|  - baselineCommand: string                                                     |
+|  - baselineResult: string                                                      |
+|  - recoveryNotes: string[]                                                     |
++-------------------------------------------------------------------------------+
+|  + summarize(): string                    --> Returns reviewer-facing summary  |
+|  + isComplete(): boolean                  --> Checks required evidence fields  |
+|  + missingFields(): string[]              --> Lists absent evidence fields     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Git Ref Verifier
+
+```text
++-------------------------------------------------------------------------------+
+|                                  GitRefVerifier                                |
++-------------------------------------------------------------------------------+
+|  - remoteName: string                                                          |
+|  - localRefs: Map<string, string>                                              |
+|  - remoteRefs: Map<string, string>                                             |
++-------------------------------------------------------------------------------+
+|  + verifyLocal(ref): boolean              --> Confirms local ref resolves      |
+|  + verifyRemote(ref): boolean             --> Confirms remote ref resolves     |
+|  + verifyTarget(ref, sha): boolean        --> Confirms ref target commit       |
+|  + verifyTagSignature(tag): boolean       --> Checks signed tag if configured  |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Validation Snapshot
+
+```text
++-------------------------------------------------------------------------------+
+|                                ValidationSnapshot                              |
++-------------------------------------------------------------------------------+
+|  - command: string                                                             |
+|  - passedCount: number                                                         |
+|  - failedCount: number                                                         |
+|  - artifactPath: string | null                                                 |
+|  - notes: string                                                               |
++-------------------------------------------------------------------------------+
+|  + isAcceptableBaseline(): boolean        --> Determines archive baseline use  |
+|  + toAuditText(): string                  --> Formats audit-log text           |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Treat the archive branch and signed tag as release-preservation artifacts, not runtime classes.
+* Keep snapshot metadata separate from implementation cleanup work.
+* Do not require local signing inside this phase; the human will configure signing separately.
+
+---
+
+## Data Model
+
+```ts
+type ArchiveEvidence = {
+  id: string;
+  name: string;
+  archiveBranch: string;
+  archiveTag: string;
+  expectedCommit: string;
+  baselineCommand?: string;
+  baselineResult?: string;
+  recoveryNotes?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+};
+```
+
+Required fields:
+
+* `id`
+* `name`
+* `archiveBranch`
+* `archiveTag`
+* `expectedCommit`
+
+---
+
+## Storage / State
+
+This feature uses persistent project documentation, not runtime state.
+
+```text
+Storage key: not applicable
+Storage location: docs/TORCH_OSQP_COMPLETION_AUDIT.md and .codex/code-edit-log.md
+```
+
+---
+
+## Required Methods
+
+Use function-style verification:
+
+```ts
+function verifyArchiveEvidence(input: ArchiveEvidence): VerificationReport
+```
+
+Expected output:
+
+```ts
+type VerificationReport = {
+  success: boolean;
+  missing?: string[];
+  errors?: string[];
+  summary: string;
+};
+```
+
+---
+
+## Validation Rules
+
+Before accepting archive evidence, check:
+
+1. Archive branch name is present.
+2. Archive tag name is present.
+3. Local branch resolves.
+4. Remote branch resolves.
+5. Tag resolves.
+6. Signed-tag status is either verified or explicitly documented as externally configured.
+7. Baseline result is recorded.
+
+---
+
+## UI / API Integration
+
+This feature has no UI or API surface.
+
+Internal callers:
+
+* Release auditor reads the audit and edit log.
+* Codex or a maintainer runs git verification commands.
+
+---
+
+## Workflow
+
+1. Read expected branch and tag names from the audit.
+2. Verify local refs.
+3. Verify remote refs.
+4. Verify tag metadata.
+5. Verify baseline validation notes.
+6. Record any missing evidence.
+7. Update audit or edit log only if evidence changes.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+Only create new files if archive evidence needs a dedicated manifest later.
+
+---
+
+## Files to Modify
+
+```text
+docs/TORCH_OSQP_COMPLETION_AUDIT.md
+.codex/code-edit-log.md
+```
+
+Modify only if archive evidence or recovery instructions change.
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* Local archive branch is missing.
+* Remote archive branch is missing.
+* Tag is missing.
+* Tag is unsigned or signing cannot be verified.
+* Baseline result is absent.
+* Expected commit differs from actual ref target.
+
+Prefer clear audit notes over silent assumptions.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] Local branch resolves.
+* [ ] Remote branch resolves.
+* [ ] Tag resolves.
+* [ ] Tag signature status is documented.
+* [ ] Baseline validation is recorded.
+* [ ] Recovery path is clear.
+* [ ] Active mainline work does not depend on archive-only code.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `ArchiveEvidenceRecord` is complete.
+2. Branch and tag evidence are verified or explicitly documented.
+3. Baseline validation evidence is preserved.
+4. Recovery instructions are readable.
+5. The archive proof does not overclaim active solver support.
diff --git a/docs/plans/phase_0.2_remove_research_paths_plan.md b/docs/plans/phase_0.2_remove_research_paths_plan.md
new file mode 100644
index 0000000..e7d4868
--- /dev/null
+++ b/docs/plans/phase_0.2_remove_research_paths_plan.md
@@ -0,0 +1,246 @@
+# Phase 0.2 Implementation Plan: Remove Research Execution Paths
+
+## Goal
+
+Implement **active-path cleanup for removed sparse-CG/CUDA Graph research code**.
+
+This feature should allow the system to:
+
+1. Keep only builtin OSQP and dense Torch OSQP in the active package path.
+2. Reject legacy research settings with actionable migration errors.
+3. Preserve the research implementation only on the archive branch.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `pygranso/private/osqpTorchAdapter.py`: contains `LEGACY_TORCH_SETTINGS` and backend policy.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: records removed research execution paths.
+* `archive/sparse-cg-cuda-graph`: expected location of preserved research code.
+
+The missing part is:
+
+* A repeatable plan to confirm research execution does not re-enter active code.
+* A clear data model for legacy setting rejection.
+* Explicit tests/search checks that distinguish archived code from active runtime code.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+LegacySettingGuard
+```
+
+Responsibility:
+
+```text
+Detect archived sparse-CG/CUDA Graph options and raise migration errors before backend selection.
+```
+
+### Component 2
+
+```text
+ActivePathAudit
+```
+
+Responsibility:
+
+```text
+Search active package files for removed execution paths and summarize whether runtime cleanup remains true.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Legacy Setting Guard
+
+```text
++-------------------------------------------------------------------------------+
+|                                LegacySettingGuard                              |
++-------------------------------------------------------------------------------+
+|  - legacyKeys: Set<string>                                                     |
+|  - migrationRelease: string                                                    |
+|  - removalRelease: string                                                      |
++-------------------------------------------------------------------------------+
+|  + detect(settings): string[]             --> Returns legacy keys in settings  |
+|  + buildMessage(keys): string             --> Creates actionable error text    |
+|  + raiseIfPresent(settings): void         --> Stops archived option execution  |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Active Path Audit
+
+```text
++-------------------------------------------------------------------------------+
+|                                  ActivePathAudit                               |
++-------------------------------------------------------------------------------+
+|  - packageRoots: string[]                                                      |
+|  - forbiddenSymbols: string[]                                                  |
+|  - archiveRef: string                                                          |
++-------------------------------------------------------------------------------+
+|  + scan(): AuditFinding[]                 --> Searches active package files    |
+|  + hasRuntimeReference(): boolean         --> True if forbidden code remains   |
+|  + summarize(): string                    --> Produces audit-ready summary     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Removed Research Feature
+
+```text
++-------------------------------------------------------------------------------+
+|                               RemovedResearchFeature                           |
++-------------------------------------------------------------------------------+
+|  - name: string                                                                |
+|  - oldOption: string                                                           |
+|  - archiveLocation: string                                                     |
+|  - replacement: string                                                         |
+|  - removalReason: string                                                       |
++-------------------------------------------------------------------------------+
+|  + migrationNote(): string                --> Explains replacement path        |
+|  + isArchivedOnly(): boolean              --> Confirms active path exclusion   |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Treat removed research paths as implementation boundaries, not user-facing features.
+* Keep archival metadata out of the main package path.
+* Preserve dense direct behavior while deleting CG, sparse-operator, CUDA Graph, and npm artifacts.
+
+---
+
+## Data Model
+
+```ts
+type RemovedResearchFeature = {
+  id: string;
+  name: string;
+  oldOption: string;
+  archiveLocation: string;
+  replacement: string;
+  removalReason?: string;
+  createdAt?: string;
+  updatedAt?: string;
+};
+```
+
+---
+
+## Storage / State
+
+This feature is mostly stateless. It receives settings or source paths, returns
+validation/audit output, and does not persist runtime data.
+
+Persistent documentation state lives in:
+
+```text
+docs/TORCH_OSQP_COMPLETION_AUDIT.md
+docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
+```
+
+---
+
+## Required Methods
+
+```ts
+function detectLegacySettings(settings: dict): string[]
+```
+
+```ts
+function auditActiveResearchPaths(packageRoots: string[]): AuditFinding[]
+```
+
+---
+
+## Validation Rules
+
+Before backend selection:
+
+1. Detect `linear_solver`, `cg_*`, `cuda_graph`, and archived auto-selection settings.
+2. Reject legacy settings with migration guidance.
+3. Do not silently ignore settings that used to change solver behavior.
+4. Do not import removed research modules from active code.
+
+---
+
+## UI / API Integration
+
+This feature has no UI.
+
+API surface:
+
+* `_normalize_options(options, dtype)` calls the legacy-setting guard.
+* Tests call the adapter and assert migration errors.
+
+---
+
+## Workflow
+
+1. User passes `osqp_settings`.
+2. Adapter normalizes options.
+3. Legacy guard detects archived keys.
+4. Adapter raises an actionable error.
+5. Active-path audit confirms removed runtime paths are absent.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+---
+
+## Files to Modify
+
+```text
+pygranso/private/osqpTorchAdapter.py
+tests/test_torch_osqp_policy.py
+docs/TORCH_OSQP_COMPLETION_AUDIT.md
+```
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* User requests archived CG settings.
+* User requests CUDA Graph settings.
+* User requests sparse-operator auto-selection settings.
+* Active code accidentally imports archive-only modules.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] Legacy `linear_solver` setting raises.
+* [ ] Legacy CG tolerance setting raises.
+* [ ] Legacy CUDA Graph setting raises.
+* [ ] Active package path has no custom CG execution.
+* [ ] Active package path has no CUDA Graph execution.
+* [ ] Archive branch remains the recovery path.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `LegacySettingGuard` behavior is active.
+2. Removed research options cannot execute active code.
+3. Errors are clear and safe.
+4. Tests or search checks confirm the active path is dense-reference only.
diff --git a/docs/plans/phase_1.1_public_qp_contract_plan.md b/docs/plans/phase_1.1_public_qp_contract_plan.md
new file mode 100644
index 0000000..cce9ed2
--- /dev/null
+++ b/docs/plans/phase_1.1_public_qp_contract_plan.md
@@ -0,0 +1,259 @@
+# Phase 1.1 Implementation Plan: Public QP Contract
+
+## Goal
+
+Implement **the public PyGRANSO-to-OSQP QP contract**.
+
+This feature should allow the system to:
+
+1. Accept PyGRANSO QP inputs consistently.
+2. Convert them to canonical OSQP form.
+3. Reject invalid shapes, dtypes, devices, bounds, and nonfinite values early.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `pygranso/private/solveQP.py`: receives PyGRANSO QP arguments.
+* `pygranso/private/osqpTorchAdapter.py`: routes QPs to builtin or Torch OSQP.
+* `_build_constraints_torch` and `_build_constraints_numpy`: build OSQP constraints.
+
+The missing part is:
+
+* A standalone implementation plan for the canonical QP boundary.
+* Clear input/output type definitions for the adapter contract.
+* A checklist tying validation behavior to files and tests.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+PygransoQPInput
+```
+
+Responsibility:
+
+```text
+Represent the raw QP data produced by PyGRANSO before OSQP canonicalization.
+```
+
+### Component 2
+
+```text
+CanonicalOSQPProblem
+```
+
+Responsibility:
+
+```text
+Represent the validated OSQP problem `min 0.5*x'Px + q'x` subject to `l <= Ax <= u`.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: PyGRANSO QP Input
+
+```text
++-------------------------------------------------------------------------------+
+|                                 PygransoQPInput                                |
++-------------------------------------------------------------------------------+
+|  - H: torch.Tensor                                                             |
+|  - f: torch.Tensor                                                             |
+|  - A: torch.Tensor | None                                                      |
+|  - b: torch.Tensor | None                                                      |
+|  - LB: torch.Tensor                                                            |
+|  - UB: torch.Tensor                                                            |
+|  - torchDevice: torch.device                                                   |
+|  - doublePrecision: boolean                                                    |
++-------------------------------------------------------------------------------+
+|  + validateShape(): void                  --> Checks dimensions and columns    |
+|  + validateDtype(): void                  --> Checks float32/float64 contract  |
+|  + validateDevice(): void                 --> Checks compatible devices        |
+|  + variableCount(): number                --> Returns QP dimension n           |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Canonical OSQP Problem
+
+```text
++-------------------------------------------------------------------------------+
+|                              CanonicalOSQPProblem                              |
++-------------------------------------------------------------------------------+
+|  - P: torch.Tensor                                                             |
+|  - q: torch.Tensor                                                             |
+|  - A_osqp: torch.Tensor                                                        |
+|  - l: torch.Tensor                                                             |
+|  - u: torch.Tensor                                                             |
+|  - constraintOrderSignature: tuple                                             |
++-------------------------------------------------------------------------------+
+|  + validateBounds(): void                 --> Rejects NaN and l > u            |
+|  + objective(x): float                    --> Computes canonical objective     |
+|  + kktDimension(): number                 --> Returns n + m                    |
+|  + toBuiltinArrays(): tuple               --> Produces NumPy/scipy inputs      |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Constraint Assembler
+
+```text
++-------------------------------------------------------------------------------+
+|                                ConstraintAssembler                             |
++-------------------------------------------------------------------------------+
+|  - No persistent internal state                                                |
++-------------------------------------------------------------------------------+
+|  + buildTorch(A,b,LB,UB,n): tuple         --> Builds Torch A,l,u rows          |
+|  + buildNumpy(A,b,LB,UB,n): tuple         --> Builds builtin sparse rows       |
+|  + orderSignature(A,b,n): tuple           --> Records equality/bound ordering  |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* The public contract should remain small and stable.
+* Validation classes are internal helpers, not new public APIs.
+* Backend-specific implementation details must not leak into the public QP option surface.
+
+---
+
+## Data Model
+
+```ts
+type QPContractInput = {
+  id: string;
+  name: string;
+  H: "Tensor[n,n]";
+  f: "Tensor[n] or Tensor[n,1]";
+  A?: "Tensor[p,n]";
+  b?: "Tensor[p] or Tensor[p,1]";
+  LB: "Tensor[n,1]";
+  UB: "Tensor[n,1]";
+  dtype: "float32" | "float64";
+  device: string;
+};
+```
+
+---
+
+## Storage / State
+
+This feature is stateless. It receives input, returns canonical output, and does not persist data.
+
+Temporary state:
+
+* Canonical tensors during one solve.
+* Constraint order signature passed into solver settings.
+
+---
+
+## Required Methods
+
+```ts
+function canonicalizePygransoQP(input: QPContractInput): CanonicalOSQPProblem
+```
+
+```ts
+function validateCanonicalProblem(problem: CanonicalOSQPProblem): void
+```
+
+---
+
+## Validation Rules
+
+Before processing data, check:
+
+1. `H` is square and matches `len(f)`.
+2. `LB` and `UB` are column vectors with `n` entries.
+3. Equality rows have compatible `A` and `b`.
+4. Matrices and finite vectors contain no NaN/Inf.
+5. Infinite values are permitted only in bounds.
+6. Every lower bound is less than or equal to its upper bound.
+
+---
+
+## UI / API Integration
+
+This feature is internal.
+
+Callers:
+
+* `solveQP(...)` passes raw QP data.
+* `solve_osqp_torch_qp(...)` normalizes and selects backend.
+* Builtin and Torch paths consume canonical problem data.
+
+---
+
+## Workflow
+
+1. Receive PyGRANSO QP input.
+2. Validate base shapes and dtype.
+3. Build equality rows if present.
+4. Append variable-bound identity rows.
+5. Produce `P`, `q`, `A_osqp`, `l`, `u`.
+6. Pass canonical data to selected backend.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+---
+
+## Files to Modify
+
+```text
+pygranso/private/osqpTorchAdapter.py
+pygranso/private/solveQP.py
+tests/test_torch_osqp_direct.py
+tests/test_torch_osqp_policy.py
+```
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* Missing required tensor.
+* Incompatible shapes.
+* Incompatible dtype or device.
+* Material asymmetry in `H`/`P`.
+* Invalid bounds.
+* Nonfinite data where not allowed.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] Bound-only QP canonicalizes correctly.
+* [ ] Equality-plus-bounds QP canonicalizes correctly.
+* [ ] Infinite bounds are preserved.
+* [ ] NaNs are rejected.
+* [ ] Shape mismatch raises a clear error.
+* [ ] Return solution shape remains `(n, 1)`.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `CanonicalOSQPProblem` behavior is implemented through adapter functions.
+2. Builtin and Torch routes receive equivalent QP data.
+3. Validation prevents invalid input from reaching backend solvers.
+4. Tests or manual checks confirm expected behavior.
diff --git a/docs/plans/phase_1.2_backend_policy_and_fallback_plan.md b/docs/plans/phase_1.2_backend_policy_and_fallback_plan.md
new file mode 100644
index 0000000..715a529
--- /dev/null
+++ b/docs/plans/phase_1.2_backend_policy_and_fallback_plan.md
@@ -0,0 +1,266 @@
+# Phase 1.2 Implementation Plan: Backend Policy and Fallback Telemetry
+
+## Goal
+
+Implement **backend policy and fallback telemetry**.
+
+This feature should allow the system to:
+
+1. Select `builtin` or `torch` from the public `osqp_algebra` contract.
+2. Make every automatic fallback visible and causal.
+3. Prevent explicit `torch` requests from silently changing backend.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `_select_backend(...)`: chooses builtin or Torch based on request, device, size, memory, and promotion.
+* `_accelerator_capability(...)`: checks CUDA, ROCm, and MPS promotion status.
+* `info["fallback"]`: records automatic fallback details.
+
+The missing part is:
+
+* A template-based implementation plan for the policy data structures.
+* Clear acceptance criteria for explicit vs automatic backend behavior.
+* A testing checklist for fallback telemetry fields.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+BackendSelection
+```
+
+Responsibility:
+
+```text
+Represent the requested backend, selected backend, dense KKT estimate, memory estimate, and selection reason.
+```
+
+### Component 2
+
+```text
+FallbackTelemetry
+```
+
+Responsibility:
+
+```text
+Represent why an automatic request fell back, what backend was tried, and what result or exception caused the retry.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Backend Selection
+
+```text
++-------------------------------------------------------------------------------+
+|                                BackendSelection                                |
++-------------------------------------------------------------------------------+
+|  - requestedBackend: string                                                    |
+|  - selectedBackend: string                                                     |
+|  - selectionReason: string                                                     |
+|  - estimatedKktDim: number                                                     |
+|  - estimatedDenseWorkingMemoryMb: number                                       |
+|  - fallback: FallbackTelemetry                                                 |
++-------------------------------------------------------------------------------+
+|  + isBuiltin(): boolean                   --> True when builtin will run       |
+|  + isTorch(): boolean                     --> True when Torch will run         |
+|  + toInfoFields(): dict                   --> Converts to result telemetry     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Fallback Telemetry
+
+```text
++-------------------------------------------------------------------------------+
+|                                FallbackTelemetry                               |
++-------------------------------------------------------------------------------+
+|  - occurred: boolean                                                           |
+|  - trigger: string                                                             |
+|  - requestedBackend: string                                                    |
+|  - selectedBackend: string                                                     |
+|  - fallbackBackend: string                                                     |
+|  - deviceTransfer: boolean                                                     |
+|  - status: string | null                                                       |
+|  - exceptionType: string | null                                                |
+|  - message: string | null                                                      |
++-------------------------------------------------------------------------------+
+|  + fromSelectionPolicy(reason): FallbackTelemetry --> Builds policy fallback   |
+|  + fromException(exc): FallbackTelemetry          --> Builds exception record  |
+|  + fromUnsolvedStatus(info): FallbackTelemetry    --> Builds status record     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Accelerator Capability
+
+```text
++-------------------------------------------------------------------------------+
+|                              AcceleratorCapability                             |
++-------------------------------------------------------------------------------+
+|  - deviceType: string                                                          |
+|  - dtype: torch.dtype                                                          |
+|  - promoted: boolean                                                           |
+|  - supported: boolean                                                          |
+|  - reason: string                                                              |
++-------------------------------------------------------------------------------+
+|  + requiresFallback(): boolean            --> True if auto must use builtin    |
+|  + explain(): string                      --> Returns warning reason           |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Backend selection is an adapter policy boundary, not a solver math component.
+* Fallback telemetry must explain automatic backend changes without mutating explicit requests.
+* Keep support-matrix checks separate from numerical solve diagnostics.
+
+---
+
+## Data Model
+
+```ts
+type BackendSelectionInfo = {
+  id: string;
+  name: string;
+  requestedBackend: "auto" | "builtin" | "torch";
+  selectedBackend: "builtin" | "torch";
+  selectionReason: string;
+  estimatedKktDim: number;
+  estimatedDenseWorkingMemoryMb: number;
+  fallback?: {
+    occurred: boolean;
+    trigger?: string;
+    message?: string;
+  };
+};
+```
+
+---
+
+## Storage / State
+
+This feature is stateless. It receives the QP request and settings, returns
+selection telemetry, and does not persist data.
+
+Temporary state:
+
+* Backend choice for one QP solve.
+* Fallback details for one QP solve.
+
+---
+
+## Required Methods
+
+```ts
+function selectBackend(request): BackendSelectionInfo
+```
+
+```ts
+function buildFallbackTelemetry(trigger, cause): FallbackTelemetry
+```
+
+---
+
+## Validation Rules
+
+Before selecting a backend, check:
+
+1. Public algebra is one of `auto`, `builtin`, or `torch`.
+2. CPU `auto` uses builtin.
+3. Unsupported accelerator `auto` falls back with warning.
+4. Oversized automatic Torch request falls back with warning.
+5. Explicit `torch` warns and attempts when oversized.
+6. Explicit `torch` failure propagates.
+
+---
+
+## UI / API Integration
+
+This feature is internal.
+
+Callers:
+
+* `solve_osqp_torch_qp(...)` calls `_select_backend(...)`.
+* Tests inspect returned `info` fields.
+* PyGRANSO sees failures through existing outer fallback paths.
+
+---
+
+## Workflow
+
+1. Receive `osqp_algebra`, device, dtype, and QP size.
+2. Estimate dense KKT dimension and memory.
+3. Apply explicit request rules.
+4. Apply automatic CPU/accelerator rules.
+5. Run selected backend.
+6. If automatic Torch fails or is unsolved, retry builtin and attach telemetry.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+---
+
+## Files to Modify
+
+```text
+pygranso/private/osqpTorchAdapter.py
+tests/test_torch_osqp_policy.py
+docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md
+```
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* Unknown `osqp_algebra`.
+* Unsupported accelerator.
+* KKT dimension above automatic limit.
+* Memory preflight failure.
+* Torch exception under `auto`.
+* Torch unsolved status under `auto`.
+* Explicit Torch unsolved status.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] CPU `auto` selects builtin.
+* [ ] Explicit builtin selects builtin.
+* [ ] Explicit torch selects Torch.
+* [ ] Explicit torch above limit warns and attempts.
+* [ ] Unsupported accelerator auto falls back.
+* [ ] Torch exception auto fallback records exception type.
+* [ ] Torch unsolved auto fallback records status.
+* [ ] Explicit Torch failure does not fallback silently.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `BackendSelection` fields are returned in `info`.
+2. `FallbackTelemetry` fully explains automatic fallback.
+3. Explicit backend requests remain explicit.
+4. Validation tests confirm every selection branch.
diff --git a/docs/plans/phase_1.3_settings_validation_and_migration_plan.md b/docs/plans/phase_1.3_settings_validation_and_migration_plan.md
new file mode 100644
index 0000000..5d85ba2
--- /dev/null
+++ b/docs/plans/phase_1.3_settings_validation_and_migration_plan.md
@@ -0,0 +1,275 @@
+# Phase 1.3 Implementation Plan: Settings Validation and Migration Errors
+
+## Goal
+
+Implement **settings normalization, numerical validation, and legacy migration errors**.
+
+This feature should allow the system to:
+
+1. Apply common builtin/Torch OSQP defaults.
+2. Reject invalid numerical inputs before backend execution.
+3. Reject archived CG/CUDA Graph settings with clear migration guidance.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `DEFAULT_OSQP_SETTINGS`: common adapter defaults.
+* `_normalize_options(...)`: merges user options with defaults.
+* `_validate_settings(...)`: checks settings ranges.
+* `_validate_qp(...)`: validates Torch QP tensors.
+* `LEGACY_TORCH_SETTINGS`: archived option names.
+
+The missing part is:
+
+* A single plan describing defaults, validation, and migration behavior.
+* Clear type shapes for settings and diagnostics.
+* A complete checklist of numerical validation rules.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+OSQPSettingsContract
+```
+
+Responsibility:
+
+```text
+Normalize and validate shared settings used by both builtin and Torch routes.
+```
+
+### Component 2
+
+```text
+NumericalInputValidator
+```
+
+Responsibility:
+
+```text
+Validate finite matrices, bounds, dtype/device compatibility, symmetry, and optional convexity diagnostics.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: OSQP Settings Contract
+
+```text
++-------------------------------------------------------------------------------+
+|                               OSQPSettingsContract                             |
++-------------------------------------------------------------------------------+
+|  - rho: float                                                                  |
+|  - sigma: float                                                                |
+|  - alpha: float                                                                |
+|  - maxIter: number                                                             |
+|  - epsAbs: float                                                               |
+|  - epsRel: float                                                               |
+|  - scaling: number                                                             |
+|  - adaptiveRho: boolean                                                        |
+|  - polishing: boolean                                                          |
+|  - warmStart: boolean                                                          |
++-------------------------------------------------------------------------------+
+|  + defaults(dtype): dict                  --> Returns dtype-aware defaults     |
+|  + merge(userSettings): dict              --> Applies user overrides safely    |
+|  + validate(settings): void               --> Checks ranges and types          |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Migration Error Report
+
+```text
++-------------------------------------------------------------------------------+
+|                               MigrationErrorReport                             |
++-------------------------------------------------------------------------------+
+|  - legacyKeys: string[]                                                        |
+|  - message: string                                                             |
+|  - archiveBranch: string                                                       |
+|  - replacementPath: string                                                     |
++-------------------------------------------------------------------------------+
+|  + fromSettings(settings): MigrationErrorReport | null --> Detects old keys    |
+|  + raise(): void                         --> Raises actionable migration error |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Numerical Input Validator
+
+```text
++-------------------------------------------------------------------------------+
+|                              NumericalInputValidator                           |
++-------------------------------------------------------------------------------+
+|  - dtype: torch.dtype                                                          |
+|  - device: torch.device                                                        |
+|  - symmetryToleranceMultiplier: float                                          |
+|  - checkConvexity: boolean                                                     |
++-------------------------------------------------------------------------------+
+|  + validateFinite(P,q,A): void            --> Rejects NaN/Inf matrices         |
+|  + validateBounds(l,u): void              --> Rejects NaN and l > u            |
+|  + validateSymmetry(P): Tensor            --> Symmetrizes only within tolerance|
+|  + diagnoseConvexity(P): void             --> Optional eigvalsh PSD check      |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Settings validation should normalize common defaults before backend-specific solve code runs.
+* Legacy research options should fail with actionable migration guidance after warning policy is complete.
+* Tolerance selection should depend on dtype and documented support level, not on backend preference.
+
+---
+
+## Data Model
+
+```ts
+type OSQPSettings = {
+  id: string;
+  name: string;
+  rho: number;
+  sigma: number;
+  alpha: number;
+  max_iter: number;
+  eps_abs: number;
+  eps_rel: number;
+  check_termination: number;
+  scaling: number;
+  adaptive_rho: boolean;
+  polishing: boolean;
+  warm_start: boolean;
+};
+```
+
+---
+
+## Storage / State
+
+This feature is stateless. It normalizes one settings object per solve and does not persist data.
+
+Temporary state:
+
+* Normalized settings dictionary.
+* Optional symmetry/convexity diagnostics.
+
+---
+
+## Required Methods
+
+```ts
+function normalizeSettings(options: dict, dtype: torch.dtype): OSQPSettings
+```
+
+```ts
+function validateNumericalInput(problem, settings): ValidatedProblem
+```
+
+---
+
+## Validation Rules
+
+Before saving or processing data, check:
+
+1. `rho`, `sigma`, tolerances, and iteration counts are positive where required.
+2. `alpha` is within the supported relaxation range.
+3. Dtype is float32 or float64.
+4. Devices are compatible.
+5. `P`, `q`, and `A` are finite.
+6. `l` and `u` contain no NaN and satisfy `l <= u`.
+7. Material asymmetry in `P` is rejected.
+8. Legacy settings raise migration errors.
+
+---
+
+## UI / API Integration
+
+This feature is internal.
+
+Callers:
+
+* Adapter option normalization.
+* Torch direct solver validation.
+* Builtin route symmetry validation.
+* Unit tests.
+
+---
+
+## Workflow
+
+1. Receive user options.
+2. Detect legacy settings.
+3. Merge defaults by dtype.
+4. Validate setting ranges.
+5. Validate QP tensors and bounds.
+6. Symmetrize only when safe.
+7. Optionally run convexity diagnostic.
+8. Return validated settings/problem or raise a clear error.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+---
+
+## Files to Modify
+
+```text
+pygranso/private/osqpTorchAdapter.py
+pygranso/private/torchOSQP.py
+tests/test_torch_osqp_direct.py
+tests/test_torch_osqp_policy.py
+```
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* Unknown setting type.
+* Legacy setting key.
+* Nonfinite matrix data.
+* Invalid bounds.
+* Unsupported dtype.
+* Device mismatch.
+* Material asymmetry.
+* Negative eigenvalue when convexity diagnostic is enabled.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] Float64 defaults use `1e-8`.
+* [ ] Float32 defaults use `1e-5`.
+* [ ] Legacy setting raises.
+* [ ] NaN in matrix raises.
+* [ ] NaN in bounds raises.
+* [ ] `l > u` raises.
+* [ ] Near-symmetric `P` is symmetrized.
+* [ ] Materially asymmetric `P` is rejected.
+* [ ] Optional convexity diagnostic rejects indefinite `P`.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `OSQPSettingsContract` behavior is implemented through adapter helpers.
+2. Invalid numerical input cannot reach LU or builtin OSQP setup.
+3. Legacy settings produce actionable errors.
+4. Tests confirm defaults and validation rules.
diff --git a/docs/plans/phase_2.1_dense_lu_workspace_plan.md b/docs/plans/phase_2.1_dense_lu_workspace_plan.md
new file mode 100644
index 0000000..1ac4cbd
--- /dev/null
+++ b/docs/plans/phase_2.1_dense_lu_workspace_plan.md
@@ -0,0 +1,317 @@
+# Phase 2.1 Implementation Plan: Dense LU Workspace Lifecycle
+
+## Goal
+
+Implement **optimizer-owned Torch OSQP workspace and reusable dense LU lifecycle**.
+
+This feature should allow the system to:
+
+1. Reuse LU factors across compatible ADMM iterations and vector-only solves.
+2. Preserve warm `x`, `z`, `y` state only when structure is compatible.
+3. Reset state safely on structure, dtype, device, order, or backend changes.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `pygranso/private/osqpWorkspace.py`: defines `TorchOSQPWorkspace`.
+* `pygranso/private/torchLinearSolve.py`: defines `DenseLUSolver`, `LinearSolveDiagnostics`, and `TorchLinearSolveError`.
+* `pygranso/private/bfgssqp.py`: creates one workspace per BFGS-SQP run.
+* `pygranso/private/torchOSQP.py`: prepares workspace and uses the LU solver.
+
+The missing part is:
+
+* A template-format implementation plan for the workspace/LU data model.
+* Explicit ASCII class diagrams for every class/data holder.
+* A detailed checkbox workflow for reuse, refactorization, and invalidation.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+TorchOSQPWorkspace
+```
+
+Responsibility:
+
+```text
+Own all per-optimizer Torch OSQP state, including warm vectors, signatures, scaling, rho, LU factors, builtin cache, and diagnostics.
+```
+
+### Component 2
+
+```text
+DenseLUSolver
+```
+
+Responsibility:
+
+```text
+Validate dense KKT matrices, cache PyTorch LU factors, solve repeated RHS values, and emit diagnostics.
+```
+
+### Component 3
+
+```text
+LinearSolveDiagnostics
+```
+
+Responsibility:
+
+```text
+Report factorization status, factorization/solve counts, and optional linear residuals.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Runtime State Registry
+
+```text
++-------------------------------------------------------------------------------+
+|                               TorchOSQPWorkspace                               |
++-------------------------------------------------------------------------------+
+|  - state: dict | None                                                          |
+|  - problem_signature: tuple | None                                             |
+|  - constraint_order_signature: tuple | None                                    |
+|  - p_pattern: torch.Tensor | None                                              |
+|  - a_pattern: torch.Tensor | None                                              |
+|  - scaling: dict | None                                                        |
+|  - rho_bar: float | None                                                       |
+|  - active_backend: string | None                                               |
+|  - linear_solver: DenseLUSolver                                                |
+|  - builtin_cache: dict | None                                                  |
+|  - builtin_stats: dict                                                         |
++-------------------------------------------------------------------------------+
+|  + reset_torch(): void                    --> Clears Torch warm/factor state   |
+|  + reset_builtin(): void                  --> Clears builtin cache/statistics  |
+|  + reset(): void                          --> Clears all backend state         |
+|  + ensure_backend(backend): boolean       --> Invalidates on backend change    |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Service Class
+
+```text
++-------------------------------------------------------------------------------+
+|                                  DenseLUSolver                                 |
++-------------------------------------------------------------------------------+
+|  - _matrix: torch.Tensor | None                                                |
+|  - _lu: torch.Tensor | None                                                    |
+|  - _pivots: torch.Tensor | None                                                |
+|  - _info: number                                                               |
+|  - factorization_count: number                                                 |
+|  - solve_count: number                                                         |
++-------------------------------------------------------------------------------+
+|  + clear(): void                         --> Drops cached matrix and factors   |
+|  + is_factorized_for(matrix): boolean    --> Checks exact factor reuse         |
+|  + factorize(matrix): void               --> Validates and factors K           |
+|  + refactorize(matrix): void             --> Forces a new factorization        |
+|  + factorize_if_needed(matrix): boolean  --> Reuses or factors as needed       |
+|  + solve(rhs, calculate_residual): tuple --> Solves RHS and returns diagnostics|
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Data Transfer Object
+
+```text
++-------------------------------------------------------------------------------+
+|                              LinearSolveDiagnostics                            |
++-------------------------------------------------------------------------------+
+|  - solver: string                                                              |
+|  - factorization_info: number                                                  |
+|  - factorization_count: number                                                 |
+|  - solve_count: number                                                         |
+|  - linear_residual_norm: float | None                                          |
+|  - relative_linear_residual: float | None                                      |
++-------------------------------------------------------------------------------+
+|  + as_dict(): dict                        --> Converts diagnostics to info     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: Error Class
+
+```text
++-------------------------------------------------------------------------------+
+|                              TorchLinearSolveError                             |
++-------------------------------------------------------------------------------+
+|  - message: string                                                             |
++-------------------------------------------------------------------------------+
+|  + __init__(message): void                --> Wraps LU factor/solve failures   |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* `TorchOSQPWorkspace` owns mutable solver state for exactly one BFGS-SQP run.
+* `DenseLUSolver` owns factorization lifecycle and should be the only object calling PyTorch LU primitives.
+* Diagnostics are internal telemetry and should not become module-global state.
+
+---
+
+## Data Model
+
+```ts
+type WorkspaceState = {
+  id: string;
+  name: string;
+  x?: "Tensor[n]";
+  z?: "Tensor[m]";
+  y?: "Tensor[m]";
+  problemSignature?: unknown[];
+  constraintOrderSignature?: unknown[];
+  activeBackend?: "builtin" | "torch";
+  rhoBar?: number;
+  createdAt?: string;
+  updatedAt?: string;
+};
+```
+
+---
+
+## Storage / State
+
+### Temporary State
+
+Use in-memory state owned by one `AlgBFGSSQP` run.
+
+Use this for:
+
+* Warm vectors `x`, `z`, `y`
+* Problem signatures
+* Scaling cache
+* Adaptive rho state
+* LU factors
+* Builtin OSQP cache
+* Last diagnostics
+
+No workspace state should be module-global or shared across independent runs.
+
+---
+
+## Required Methods
+
+```ts
+function prepareWorkspace(workspace, P, A, orderSignature): void
+```
+
+```ts
+function factorizeIfNeeded(K): boolean
+```
+
+```ts
+function solve(rhs): [Tensor, LinearSolveDiagnostics]
+```
+
+---
+
+## Validation Rules
+
+Before reusing state, check:
+
+1. Matrix shapes match.
+2. Constraint order signature matches.
+3. Structural patterns match.
+4. Dtype and device match.
+5. Backend has not changed.
+6. Matrix values are unchanged if LU is reused.
+7. RHS is finite and shape-compatible.
+
+---
+
+## UI / API Integration
+
+This feature is purely internal.
+
+Callers:
+
+* `AlgBFGSSQP` creates the workspace.
+* `solveQP` passes workspace through OSQP options.
+* `solve_torch_osqp_direct` consumes and updates workspace state.
+
+---
+
+## Workflow
+
+1. BFGS-SQP creates a workspace.
+2. Adapter selects backend and calls `ensure_backend`.
+3. Torch solver validates QP and prepares workspace.
+4. Compatible state is reused.
+5. Incompatible state is reset.
+6. KKT is factorized or reused.
+7. ADMM iterations solve repeated RHS values.
+8. Final warm state and diagnostics are stored.
+
+---
+
+## Files to Create
+
+```text
+None
+```
+
+---
+
+## Files to Modify
+
+```text
+pygranso/private/osqpWorkspace.py
+pygranso/private/torchLinearSolve.py
+pygranso/private/torchOSQP.py
+pygranso/private/bfgssqp.py
+tests/test_torch_linear_solve.py
+tests/test_osqp_workspace_lifecycle.py
+```
+
+---
+
+## Error Handling
+
+Handle these cases:
+
+* LU factorization is unavailable.
+* LU reports singular matrix.
+* LU factors contain nonfinite values.
+* RHS is nonfinite.
+* Solve returns nonfinite values.
+* Workspace backend changes.
+* User passes a non-workspace object.
+
+---
+
+## Testing Checklist
+
+Test the following:
+
+* [ ] Workspace starts empty.
+* [ ] Compatible vector update reuses LU.
+* [ ] Matrix-value update preserves warm state and refactorizes.
+* [ ] Rho change refactorizes.
+* [ ] Sigma change refactorizes.
+* [ ] Structure change clears warm state.
+* [ ] Backend change clears both backend caches.
+* [ ] Vector RHS shape is restored.
+* [ ] Nonfinite matrix/RHS is rejected.
+* [ ] Singular KKT raises a clear error.
+
+---
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. `TorchOSQPWorkspace` owns all reusable solver state.
+2. `DenseLUSolver` implements safe factorize/solve/refactorize behavior.
+3. `LinearSolveDiagnostics` is available in solver info.
+4. Tests confirm reuse, refactorization, and invalidation behavior.
+5. No global warm state remains.
diff --git a/docs/plans/phase_2.2_direct_admm_kernel_plan.md b/docs/plans/phase_2.2_direct_admm_kernel_plan.md
new file mode 100644
index 0000000..9ab4233
--- /dev/null
+++ b/docs/plans/phase_2.2_direct_admm_kernel_plan.md
@@ -0,0 +1,283 @@
+# Phase 2.2 Implementation Plan: Direct ADMM Kernel
+
+## Goal
+
+Implement **the dense Torch-direct ADMM kernel**.
+
+This feature should allow the system to:
+
+1. Assemble the dense OSQP KKT system with the preserved KKT, projection, dual-update, and residual equations.
+2. Run vector-only ADMM updates while reusing the workspace LU factorization from Phase 2.1.
+3. Return OSQP-compatible status, residual, objective, and diagnostic fields without claiming infeasibility certificates.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* A Torch OSQP implementation path in `pygranso/private/torchOSQP.py`.
+* A dense LU boundary in `pygranso/private/torchLinearSolve.py`.
+* Workspace ownership in `pygranso/private/osqpWorkspace.py`.
+* Pipeline requirements in `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`.
+
+The missing part is:
+
+* A clean direct-kernel boundary that separates validation, KKT assembly, ADMM iteration, and result construction.
+* Explicit input/output structures for ADMM diagnostics.
+* Tests proving that repeated ADMM iterations do not refactorize when only vector state changes.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+KKTSystemBuilder
+```
+
+Responsibility:
+
+```text
+Validate dense QP tensors and assemble the quasi-definite KKT matrix used by the Torch-direct path.
+```
+
+### Component 2
+
+```text
+DirectADMMRunner
+```
+
+Responsibility:
+
+```text
+Run ADMM vector updates, projection, dual update, termination checks, and diagnostics using a prepared workspace.
+```
+
+### Component 3
+
+```text
+DirectSolveResultBuilder
+```
+
+Responsibility:
+
+```text
+Convert Torch iteration state into the adapter's public result object and OSQP-style info fields.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: KKT System Builder
+
+```text
++-------------------------------------------------------------------------------+
+|                                KKTSystemBuilder                                |
++-------------------------------------------------------------------------------+
+|  - sigma: float                                                                |
+|  - rho: Tensor                                                                 |
+|  - dtype: torch.dtype                                                          |
+|  - device: torch.device                                                        |
++-------------------------------------------------------------------------------+
+|  + validate(P, A, q, l, u): None         --> rejects incompatible QP inputs    |
+|  + build_matrix(P, A): Tensor           --> dense KKT matrix                  |
+|  + build_rhs(state): Tensor             --> normalized column RHS             |
+|  + signature(P, A): StructuralSignature --> workspace compatibility key       |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Direct ADMM Runner
+
+```text
++-------------------------------------------------------------------------------+
+|                                DirectADMMRunner                                |
++-------------------------------------------------------------------------------+
+|  - workspace: TorchOSQPWorkspace                                               |
+|  - settings: TorchOSQPSettings                                                 |
+|  - diagnosticsEnabled: bool                                                    |
++-------------------------------------------------------------------------------+
+|  + initialize(input): ADMMState          --> creates or restores x, z, y       |
+|  + iterate_once(state): ADMMState        --> linear solve + projection update  |
+|  + check_termination(state): Status      --> residual/objective based status   |
+|  + solve(input): DirectSolveOutput       --> complete dense Torch solve        |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Result Builder
+
+```text
++-------------------------------------------------------------------------------+
+|                             DirectSolveResultBuilder                           |
++-------------------------------------------------------------------------------+
+|  - statusMap: dict                                                             |
+|  - backendName: string                                                         |
++-------------------------------------------------------------------------------+
+|  + objective(P, q, x): Tensor            --> primal objective                  |
+|  + residuals(P, A, q, l, u, x, z, y)     --> primal/dual residuals             |
+|  + info(output): dict                    --> OSQP-style telemetry              |
+|  + result(output): dict                  --> adapter return payload            |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Keep the direct ADMM runner private to the Torch implementation path.
+* Do not expose a public `linear_solver` option.
+* Keep matrix factorization delegated to `DenseLUSolver`; the ADMM runner should not call `torch.linalg.lu_factor_ex` directly.
+* Keep infeasibility and nonconvex certificates out of this phase.
+
+---
+
+## Data Model
+
+```text
+DirectADMMInput
+  P: Tensor[n,n]
+  q: Tensor[n,1]
+  A: Tensor[m,n]
+  l: Tensor[m,1]
+  u: Tensor[m,1]
+  settings: TorchOSQPSettings
+  workspace: TorchOSQPWorkspace
+  validation_mode: bool
+```
+
+```text
+ADMMState
+  x: Tensor[n,1]
+  z: Tensor[m,1]
+  y: Tensor[m,1]
+  x_tilde: Tensor[n,1]
+  z_tilde: Tensor[m,1]
+  iteration: int
+  rho: Tensor or scalar
+```
+
+```text
+DirectSolveOutput
+  status: string
+  x: Tensor[n,1]
+  y: Tensor[m,1]
+  z: Tensor[m,1]
+  objective: float
+  pri_res: float
+  dua_res: float
+  iter: int
+  info: dict
+```
+
+---
+
+## Storage / State
+
+* Store persistent warm state only in `TorchOSQPWorkspace`.
+* Store per-iteration temporaries in local variables or an `ADMMState` holder.
+* Reuse the LU factorization when `P`, `A`, `rho`, `sigma`, dtype, device, backend, and structural signature remain compatible.
+* Refactorize when the KKT matrix changes.
+* Never store ADMM state in module globals.
+
+---
+
+## Required Methods
+
+* `_validate_torch_qp_inputs(P, q, A, l, u, settings)`.
+* `_build_kkt_matrix(P, A, sigma, rho)`.
+* `_build_kkt_rhs(P, q, A, state, settings)`.
+* `_project_box(v, l, u)`.
+* `_admm_iteration(state, factors, input)`.
+* `_compute_residuals(P, q, A, l, u, state)`.
+* `_torch_direct_solve(input)`.
+* `_build_torch_result(output)`.
+
+---
+
+## Validation Rules
+
+* Reject NaNs and nonfinite finite-bound values.
+* Permit infinite bounds for OSQP-style box constraints.
+* Normalize vector RHS values to column tensors.
+* Reject incompatible shapes, devices, and dtypes.
+* Reject `l > u`.
+* Reject material asymmetry in `P`; symmetrize only within dtype-aware tolerance.
+* Check LU factorization status and solution finiteness through `DenseLUSolver`.
+* Compute expensive residual diagnostics only in validation/debug mode unless needed for termination.
+* Report numerical failures as solver failures, never as infeasibility.
+
+---
+
+## UI / API Integration
+
+* Keep public selection through `osqp_algebra={"auto","builtin","torch"}`.
+* Do not expose the direct kernel or LU object as public API.
+* Return complete backend telemetry through existing QP result/info dictionaries.
+* Preserve PyGRANSO outer fallback behavior for explicit `torch` failures.
+
+---
+
+## Workflow
+
+1. Convert user inputs to dense Torch tensors with a shared validation path.
+2. Restore compatible warm `x`, `z`, and `y` from the workspace.
+3. Build or reuse the KKT factorization through `DenseLUSolver`.
+4. For each ADMM iteration:
+   1. Build the vector RHS.
+   2. Solve with cached LU factors.
+   3. Apply relaxation and box projection.
+   4. Update the scaled/unscaled dual variables using the preserved equations.
+   5. Check termination at the configured interval.
+5. Persist compatible final `x`, `z`, and `y` back to the workspace.
+6. Return OSQP-style status, objective, residual, and diagnostic telemetry.
+
+---
+
+## Files to Create
+
+* `tests/test_torch_osqp_direct_admm.py`: direct-kernel tests for KKT assembly, updates, termination, and finite behavior.
+
+---
+
+## Files to Modify
+
+* `pygranso/private/torchOSQP.py`: split the direct solve into validation, KKT, iteration, and result helpers.
+* `pygranso/private/osqpWorkspace.py`: expose any missing workspace hooks required by the direct kernel.
+* `pygranso/private/torchLinearSolve.py`: tighten RHS normalization or diagnostics if needed by ADMM tests.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: record implementation status after code work.
+
+---
+
+## Error Handling
+
+* Raise `ValueError` for invalid user inputs.
+* Raise `TorchLinearSolveError` for factorization and solve failures.
+* Raise a Torch OSQP numerical error for nonfinite iterates, residuals, or objective values.
+* For `auto`, let the adapter convert Torch failure into warned builtin fallback telemetry.
+* For explicit `torch`, surface the failure without silently switching backend.
+
+---
+
+## Testing Checklist
+
+- [x] KKT matrix block dimensions match `(n+m, n+m)`.
+- [x] RHS vector inputs are normalized to `(n+m, 1)`.
+- [x] ADMM projection handles finite and infinite bounds.
+- [x] Dual update matches the preserved OSQP equations.
+- [x] Residual and objective diagnostics are finite on supported feasible convex QPs.
+- [x] LU factorization count does not increase for vector-only ADMM iterations.
+- [x] Explicit `torch` numerical failure raises.
+- [x] `auto` numerical failure produces causal fallback telemetry.
+
+---
+
+## Acceptance Criteria
+
+* Dense Torch-direct ADMM solves supported feasible convex QPs with float64 as the authoritative path.
+* The implementation reuses LU factors across ADMM iterations.
+* Numerical failures are never labeled infeasible.
+* Tests cover input validation, KKT assembly, projection, dual update, residuals, and telemetry.
diff --git a/docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md b/docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md
new file mode 100644
index 0000000..d0ddbab
--- /dev/null
+++ b/docs/plans/phase_2.3_scaling_adaptive_polishing_plan.md
@@ -0,0 +1,303 @@
+# Phase 2.3 Implementation Plan: Scaling, Adaptive Rho, and Polishing
+
+## Goal
+
+Implement **Ruiz scaling, adaptive `rho`, strict polishing, and structurally compatible warm starts**.
+
+This feature should allow the system to:
+
+1. Preserve the mathematically correct scaling, residual, adaptive-`rho`, and polishing behavior from the revised pipeline.
+2. Keep all scaling and warm-state data private to the optimizer-owned workspace.
+3. Raise on requested polishing failure instead of hiding it behind a successful status.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* The dense LU boundary and workspace lifecycle planned in Phase 2.1.
+* The direct ADMM loop planned in Phase 2.2.
+* Documentation requiring Ruiz scaling, adaptive `rho`, polishing, and warm starts.
+
+The missing part is:
+
+* A clear data model for scaling maps and warm-state transformations.
+* Deterministic adaptive-`rho` behavior shared with builtin OSQP settings.
+* Strict polishing behavior and tests for both success and failure.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+RuizScalingCache
+```
+
+Responsibility:
+
+```text
+Store diagonal problem scaling, objective scaling, and unscale operations for dense Torch QPs.
+```
+
+### Component 2
+
+```text
+AdaptiveRhoController
+```
+
+Responsibility:
+
+```text
+Update rho deterministically based on residual balance and request workspace refactorization when rho changes.
+```
+
+### Component 3
+
+```text
+PolishingSolver
+```
+
+Responsibility:
+
+```text
+Perform the optional active-set polishing solve and enforce requested-polishing failure semantics.
+```
+
+### Component 4
+
+```text
+WarmStartMapper
+```
+
+Responsibility:
+
+```text
+Preserve, scale, unscale, and invalidate warm x/z/y state only for structurally compatible problems.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Ruiz Scaling Cache
+
+```text
++-------------------------------------------------------------------------------+
+|                                RuizScalingCache                                |
++-------------------------------------------------------------------------------+
+|  - D: Tensor[n,1]                                                              |
+|  - E: Tensor[m,1]                                                              |
+|  - c: Tensor[1]                                                                |
+|  - passes: int                                                                 |
++-------------------------------------------------------------------------------+
+|  + fit(P, q, A, l, u): ScaledQP          --> builds scaled tensors             |
+|  + scale_state(x, z, y): ADMMState       --> maps warm state into scaled space |
+|  + unscale_solution(x, y): Solution      --> maps solver output to user space  |
+|  + compatible(signature): bool           --> checks reuse eligibility          |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Adaptive Rho Controller
+
+```text
++-------------------------------------------------------------------------------+
+|                              AdaptiveRhoController                             |
++-------------------------------------------------------------------------------+
+|  - interval: int                                                               |
+|  - tolerance: float                                                            |
+|  - enabled: bool                                                               |
++-------------------------------------------------------------------------------+
+|  + should_check(iter): boolean          --> deterministic interval gate        |
+|  + propose(pri_res, dua_res, rho): rho  --> residual-balance update           |
+|  + apply(workspace, rho): None          --> invalidates factorization on change|
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Polishing Solver
+
+```text
++-------------------------------------------------------------------------------+
+|                                  PolishingSolver                               |
++-------------------------------------------------------------------------------+
+|  - requested: bool                                                             |
+|  - regularization: float                                                       |
++-------------------------------------------------------------------------------+
+|  + identify_active_set(z, l, u): ActiveSet  --> bound activity mask            |
+|  + solve_reduced_kkt(input, activeSet): Sol  --> dense correction solve        |
+|  + accept(candidate, base): Solution         --> residual/objective gate       |
+|  + require_success(result): None             --> raises if requested failed    |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: Warm Start Mapper
+
+```text
++-------------------------------------------------------------------------------+
+|                                  WarmStartMapper                               |
++-------------------------------------------------------------------------------+
+|  - workspace: TorchOSQPWorkspace                                               |
++-------------------------------------------------------------------------------+
+|  + can_reuse(signature): boolean          --> structure/order compatibility    |
+|  + load(defaults): ADMMState              --> restores x/z/y or cold starts    |
+|  + store(finalState): None                --> persists final x/z/y             |
+|  + invalidate(reason): None               --> clears incompatible warm state   |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Scaling, adaptive `rho`, polishing, and warm starts remain private implementation details.
+* Workspace invalidation must be explicit and reason-coded.
+* Adaptive `rho` may change numeric factorization state but must not change public backend selection.
+* Polishing uses dense linear algebra only in this milestone.
+
+---
+
+## Data Model
+
+```text
+ScaledQP
+  P_scaled: Tensor[n,n]
+  q_scaled: Tensor[n,1]
+  A_scaled: Tensor[m,n]
+  l_scaled: Tensor[m,1]
+  u_scaled: Tensor[m,1]
+  scaling: RuizScalingCache
+```
+
+```text
+AdaptiveRhoState
+  rho: Tensor or scalar
+  last_update_iter: int
+  refactorization_required: bool
+  update_count: int
+```
+
+```text
+PolishResult
+  attempted: bool
+  success: bool
+  reason: string
+  x: Tensor[n,1]
+  y: Tensor[m,1]
+  objective: float
+  residuals: dict
+```
+
+---
+
+## Storage / State
+
+* Store scaling cache, adaptive-`rho` state, and warm vectors in `TorchOSQPWorkspace`.
+* Store polishing active sets and reduced solves as local temporaries.
+* Invalidate scaling and warm starts on dimension, order, structure, dtype, device, or backend changes.
+* Preserve `x`, `z`, and `y` for compatible matrix-value updates.
+* Refactorize when adaptive `rho` changes the KKT system.
+
+---
+
+## Required Methods
+
+* `_ruiz_scale_problem(P, q, A, l, u, passes=10)`.
+* `_ruiz_unscale_solution(x, y, scaling)`.
+* `_maybe_update_rho(state, residuals, settings, workspace)`.
+* `_invalidate_after_rho_change(workspace, new_rho)`.
+* `_identify_polish_active_set(z, l, u)`.
+* `_polish_solution(input, state, scaling)`.
+* `_load_warm_start(workspace, signature)`.
+* `_store_warm_start(workspace, state, signature)`.
+
+---
+
+## Validation Rules
+
+* Scaling must preserve finite user data and allow infinite bounds.
+* Scaling passes default to 10 and must be deterministic.
+* Adaptive `rho` defaults to enabled, interval 50, tolerance 5.
+* Adaptive `rho` must refactorize only when the effective KKT matrix changes.
+* Polishing failure raises when polishing was requested.
+* Warm starts must never cross incompatible dimensions, constraint order, dtype, device, backend, or structure.
+* Residuals used for adaptive `rho` must be computed in the correct scaled or unscaled space by design, not by accident.
+
+---
+
+## UI / API Integration
+
+* Use common adapter defaults for builtin and Torch:
+  * `rho=0.1`
+  * `sigma=1e-6`
+  * `alpha=1.6`
+  * `max_iter=4000`
+  * `check_termination=25`
+  * Ruiz scaling passes `10`
+  * adaptive `rho` interval `50`
+  * adaptive `rho` tolerance `5`
+* Expose polishing and warm-start behavior through existing options only.
+* Do not add a public linear-solver selector.
+
+---
+
+## Workflow
+
+1. Validate the original dense QP.
+2. Build or reuse a compatible `RuizScalingCache`.
+3. Map warm state into scaled solver space when allowed.
+4. Run ADMM with deterministic adaptive-`rho` checks.
+5. Refactorize through the workspace when `rho` changes.
+6. Attempt polishing when requested.
+7. If polishing succeeds, return the polished solution.
+8. If polishing is requested and fails, raise with actionable diagnostics.
+9. Unscale the final solution and persist compatible warm state.
+
+---
+
+## Files to Create
+
+* `tests/test_torch_osqp_scaling_adaptive_polishing.py`: scaling, adaptive-`rho`, polishing, and warm-start tests.
+
+---
+
+## Files to Modify
+
+* `pygranso/private/torchOSQP.py`: add scaling, adaptive-`rho`, polishing, and warm-state hooks.
+* `pygranso/private/osqpWorkspace.py`: store scaling cache, adaptive-`rho` state, and invalidation reasons.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: track implementation and test evidence.
+
+---
+
+## Error Handling
+
+* Raise `ValueError` for invalid scaling inputs.
+* Raise a Torch OSQP numerical error for nonfinite scaled tensors or residuals.
+* Raise a polishing-specific error when requested polishing fails.
+* Attach workspace invalidation reason and adaptive-`rho` update count to diagnostics.
+
+---
+
+## Testing Checklist
+
+- [x] Ruiz scaling is deterministic for fixed inputs.
+- [x] Scaled/unscaled solutions preserve feasibility and objective within tolerance.
+- [x] Infinite bounds remain valid through scaling.
+- [x] Adaptive `rho` updates at deterministic intervals only.
+- [x] Adaptive `rho` triggers refactorization exactly when needed.
+- [x] Warm starts are reused for compatible value updates.
+- [x] Warm starts are invalidated for structure, dtype, device, order, and backend changes.
+- [x] Requested polishing success improves or preserves accepted residual/objective diagnostics.
+- [x] Requested polishing failure raises.
+
+---
+
+## Acceptance Criteria
+
+* Torch and builtin paths share the documented default settings.
+* Scaling, adaptive `rho`, polishing, and warm starts are private, deterministic, and test-covered.
+* Polishing failures are visible when polishing is requested.
+* Workspace state remains local to a BFGS-SQP run and cannot leak through module globals.
diff --git a/docs/plans/phase_3.1_builtin_parity_plan.md b/docs/plans/phase_3.1_builtin_parity_plan.md
new file mode 100644
index 0000000..bc21db8
--- /dev/null
+++ b/docs/plans/phase_3.1_builtin_parity_plan.md
@@ -0,0 +1,267 @@
+# Phase 3.1 Implementation Plan: Builtin OSQP Parity
+
+## Goal
+
+Implement **builtin OSQP parity for the Torch-direct adapter**.
+
+This feature should allow the system to:
+
+1. Compare Torch and builtin OSQP under identical adapter settings.
+2. Report status compatibility, feasibility, stationarity, residuals, and normalized objective gaps.
+3. Avoid comparing iterates or iteration counts as correctness requirements.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* A builtin OSQP path for CPU solves.
+* A Torch OSQP path for dense reference solves.
+* Documentation requiring observable agreement with builtin OSQP.
+
+The missing part is:
+
+* A shared parity metric layer used by tests and fallback telemetry.
+* A builtin-result adapter that normalizes info fields to match Torch diagnostics.
+* Differential tests that use identical settings for both backends.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+CommonOSQPSettings
+```
+
+Responsibility:
+
+```text
+Represent the settings that must be applied identically to builtin and Torch OSQP paths.
+```
+
+### Component 2
+
+```text
+CommonAdapterMetrics
+```
+
+Responsibility:
+
+```text
+Compute backend-neutral feasibility, stationarity, residual, and objective-gap metrics.
+```
+
+### Component 3
+
+```text
+DifferentialComparison
+```
+
+Responsibility:
+
+```text
+Summarize compatibility between builtin and Torch results without requiring identical iterates.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Common Settings
+
+```text
++-------------------------------------------------------------------------------+
+|                                CommonOSQPSettings                              |
++-------------------------------------------------------------------------------+
+|  - rho: float = 0.1                                                            |
+|  - sigma: float = 1e-6                                                         |
+|  - alpha: float = 1.6                                                          |
+|  - max_iter: int = 4000                                                        |
+|  - check_termination: int = 25                                                 |
+|  - scaling: int = 10                                                           |
+|  - adaptive_rho: bool = true                                                   |
+|  - adaptive_rho_interval: int = 50                                             |
+|  - adaptive_rho_tolerance: float = 5                                           |
++-------------------------------------------------------------------------------+
+|  + for_builtin(): dict                  --> OSQP Python settings              |
+|  + for_torch(): TorchOSQPSettings       --> Torch settings                    |
+|  + tolerances(dtype): ToleranceSpec      --> float64/float32 tolerances        |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Common Adapter Metrics
+
+```text
++-------------------------------------------------------------------------------+
+|                              CommonAdapterMetrics                              |
++-------------------------------------------------------------------------------+
+|  - toleranceSpec: ToleranceSpec                                                |
++-------------------------------------------------------------------------------+
+|  + feasibility(A, l, u, x): float       --> bound violation                   |
+|  + stationarity(P, q, A, x, y): float   --> KKT stationarity residual          |
+|  + objective(P, q, x): float            --> primal objective                  |
+|  + objective_gap(torch, builtin): float  --> normalized objective gap          |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Differential Comparison
+
+```text
++-------------------------------------------------------------------------------+
+|                              DifferentialComparison                            |
++-------------------------------------------------------------------------------+
+|  - torchResult: dict                                                           |
+|  - builtinResult: dict                                                         |
+|  - metrics: CommonAdapterMetrics                                               |
++-------------------------------------------------------------------------------+
+|  + status_compatible(): boolean         --> solved/limited/error class check   |
+|  + residuals_compatible(): boolean      --> residual thresholds                |
+|  + objective_compatible(): boolean      --> normalized objective gap check     |
+|  + report(): dict                       --> case-level comparison output       |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Parity checks compare mathematical outcomes, not solver internals.
+* The builtin path remains the CPU fallback and reference oracle for supported cases.
+* Metric code should be reusable by unit tests, differential tests, and stability evidence generation.
+* The metric layer must not mutate solver state.
+
+---
+
+## Data Model
+
+```text
+ToleranceSpec
+  dtype: torch.dtype
+  feasibility_tol: float
+  stationarity_tol: float
+  residual_tol: float
+  objective_gap_tol: float
+```
+
+```text
+BackendResultView
+  backend: string
+  status: string
+  x: array or Tensor
+  y: array or Tensor
+  objective: float
+  pri_res: float
+  dua_res: float
+  info: dict
+```
+
+```text
+ComparisonReport
+  case_id: string
+  status_compatible: bool
+  feasibility_ok: bool
+  stationarity_ok: bool
+  residuals_ok: bool
+  objective_gap_ok: bool
+  notes: list[string]
+```
+
+---
+
+## Storage / State
+
+* Store no persistent parity state in the solver.
+* Store case-level reports only in test artifacts or stability evidence outputs.
+* Use workspace diagnostics as read-only input for comparison reports.
+
+---
+
+## Required Methods
+
+* `_common_osqp_settings(options, dtype)`.
+* `_solve_builtin_osqp_common(input, settings)`.
+* `_backend_result_view(result)`.
+* `_compute_common_metrics(P, q, A, l, u, result)`.
+* `_compare_backend_results(torch_result, builtin_result, tolerances)`.
+* `_normalized_objective_gap(obj_a, obj_b)`.
+
+---
+
+## Validation Rules
+
+* Differential tests must use identical settings for Torch and builtin OSQP.
+* Float64 tolerance defaults to `1e-8`.
+* Float32 tolerance defaults to `1e-5`.
+* Status compatibility should allow equivalent solved classes but reject hidden numerical failure.
+* Do not require identical `x`, `y`, `z`, iteration counts, or rho histories.
+* Objective gaps must be normalized to avoid false failures near large objectives.
+
+---
+
+## UI / API Integration
+
+* Keep parity metrics internal to tests, diagnostics, and telemetry.
+* Include comparison fields in stability CSV and Markdown summaries.
+* Do not expose a new public comparison API unless a later milestone requires it.
+
+---
+
+## Workflow
+
+1. Build a supported dense QP case.
+2. Convert options into `CommonOSQPSettings`.
+3. Solve once with builtin OSQP.
+4. Solve once with Torch OSQP.
+5. Convert both results into `BackendResultView`.
+6. Compute feasibility, stationarity, residual, and objective metrics.
+7. Write a `ComparisonReport`.
+8. Fail the gate only on unexplained unsupported status, residual, feasibility, stationarity, or objective-gap failure.
+
+---
+
+## Files to Create
+
+* `tests/test_torch_osqp_builtin_parity.py`: deterministic parity cases and result comparison tests.
+* `tests/helpers/torch_osqp_parity.py`: optional shared comparison helpers if test reuse becomes large.
+
+---
+
+## Files to Modify
+
+* `pygranso/private/solveQP.py`: share common settings and result views where needed.
+* `pygranso/private/torchOSQP.py`: expose internal diagnostics required for parity reports.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: record parity status.
+
+---
+
+## Error Handling
+
+* Treat builtin OSQP setup errors as test setup failures.
+* Treat Torch numerical failures as backend failures, not infeasibility.
+* Include both backend info dictionaries in differential failure messages.
+* Serialize failing QP inputs for stability reproduction in later phases.
+
+---
+
+## Testing Checklist
+
+- [x] Identical settings are passed to builtin and Torch paths.
+- [x] Float64 parity uses `1e-8` tolerances.
+- [x] Float32 parity uses `1e-5` tolerances.
+- [x] Status compatibility is checked independently from iterates.
+- [x] Feasibility and stationarity metrics catch intentionally corrupted results.
+- [x] Normalized objective gap handles near-zero and large objectives.
+- [x] Differential failure output includes enough telemetry to reproduce the case.
+
+---
+
+## Acceptance Criteria
+
+* Builtin and Torch results have a shared comparison vocabulary.
+* Differential tests check mathematical agreement, not implementation identity.
+* Parity evidence can be reused by the stability evidence package.
diff --git a/docs/plans/phase_3.2_pygranso_integration_plan.md b/docs/plans/phase_3.2_pygranso_integration_plan.md
new file mode 100644
index 0000000..0a3870d
--- /dev/null
+++ b/docs/plans/phase_3.2_pygranso_integration_plan.md
@@ -0,0 +1,265 @@
+# Phase 3.2 Implementation Plan: PyGRANSO Integration
+
+## Goal
+
+Implement **end-to-end PyGRANSO integration for the revised Torch-OSQP path**.
+
+This feature should allow the system to:
+
+1. Route BFGS-SQP QP subproblems through `osqp_algebra={"auto","builtin","torch"}`.
+2. Preserve PyGRANSO steering, stationarity, penalty update, and fallback semantics.
+3. Validate complete constrained optimization runs, not only isolated QP solves.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* BFGS-SQP integration code in `pygranso/private/bfgssqp.py`.
+* QP solve routing in `pygranso/private/solveQP.py`.
+* Steering and termination logic in private PyGRANSO modules.
+* Documentation requiring B1/B2/B3 and complete constrained optimization coverage.
+
+The missing part is:
+
+* A precise bridge contract between BFGS-SQP and the revised dense Torch QP solver.
+* Integration tests that verify PyGRANSO-level behavior under builtin, Torch, and fallback paths.
+* Explicit handling of workspace lifetime per BFGS-SQP run.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+SolveQPRequest
+```
+
+Responsibility:
+
+```text
+Package the QP matrices, bounds, requested backend, optimizer device, tolerances, and workspace for one PyGRANSO subproblem.
+```
+
+### Component 2
+
+```text
+AlgBFGSSQPOSQPBridge
+```
+
+Responsibility:
+
+```text
+Own the per-run workspace and pass it through PyGRANSO QP solve calls without module globals.
+```
+
+### Component 3
+
+```text
+PyGRANSOFallbackContract
+```
+
+Responsibility:
+
+```text
+Define how automatic Torch fallback and existing outer PyGRANSO fallback behavior interact.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: QP Request
+
+```text
++-------------------------------------------------------------------------------+
+|                                  SolveQPRequest                                |
++-------------------------------------------------------------------------------+
+|  - P: Tensor or array                                                          |
+|  - q: Tensor or array                                                          |
+|  - A: Tensor or array                                                          |
+|  - l: Tensor or array                                                          |
+|  - u: Tensor or array                                                          |
+|  - osqp_algebra: string                                                        |
+|  - target_device: device                                                       |
+|  - workspace: TorchOSQPWorkspace                                               |
+|  - settings: CommonOSQPSettings                                                |
++-------------------------------------------------------------------------------+
+|  + validate_shapes(): None              --> QP adapter shape checks            |
+|  + backend_policy_input(): dict         --> auto/builtin/torch selection data  |
+|  + solver_payload(): dict               --> backend-specific solve payload     |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: BFGS-SQP Bridge
+
+```text
++-------------------------------------------------------------------------------+
+|                              AlgBFGSSQPOSQPBridge                              |
++-------------------------------------------------------------------------------+
+|  - bfgsRunId: string                                                           |
+|  - torchWorkspace: TorchOSQPWorkspace                                          |
+|  - options: pygransoStruct                                                     |
++-------------------------------------------------------------------------------+
+|  + create_workspace(): TorchOSQPWorkspace  --> called once per run             |
+|  + build_request(subproblem): SolveQPRequest --> packages QP data              |
+|  + solve(request): QPResult                --> calls solveQP                   |
+|  + finalize(result): None                  --> records diagnostics             |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Fallback Contract
+
+```text
++-------------------------------------------------------------------------------+
+|                              PyGRANSOFallbackContract                          |
++-------------------------------------------------------------------------------+
+|  - requestedBackend: string                                                    |
+|  - selectedBackend: string                                                     |
+|  - outerFallbackAllowed: bool                                                  |
++-------------------------------------------------------------------------------+
+|  + auto_fallback_allowed(): boolean      --> true only for osqp_algebra=auto   |
+|  + explicit_torch_behavior(): string     --> raise and let outer strategy act  |
+|  + telemetry_fields(): dict              --> complete causal fallback payload  |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* One `TorchOSQPWorkspace` belongs to one BFGS-SQP run.
+* The bridge may pass workspace references but must not make them global.
+* PyGRANSO-level tests should verify optimization outcomes, not only QP-level status.
+* Explicit `torch` failures are visible to PyGRANSO; automatic fallback is an adapter decision only for `auto`.
+
+---
+
+## Data Model
+
+```text
+QPSubproblemRecord
+  iteration: int
+  phase: string
+  dimensions: tuple[int,int]
+  backend_requested: string
+  backend_selected: string
+  fallback: dict
+  qp_status: string
+  steering_state: dict
+```
+
+```text
+PyGRANSOIntegrationResult
+  final_x: Tensor
+  final_f: float
+  constraint_violation: float
+  stationarity: float
+  qp_records: list[QPSubproblemRecord]
+  termination_code: int
+```
+
+---
+
+## Storage / State
+
+* Store the workspace inside the BFGS-SQP run object or closure.
+* Store per-QP records in diagnostics, not module globals.
+* Reset workspace on backend, dtype, device, dimension, order, or structure changes.
+* Preserve compatible warm state across QP subproblems from the same optimizer run.
+
+---
+
+## Required Methods
+
+* `_create_torch_osqp_workspace_for_run(options)`.
+* `_build_solve_qp_request(subproblem, options, workspace)`.
+* `_solve_qp_with_backend_policy(request)`.
+* `_record_qp_backend_telemetry(result, run_state)`.
+* `_handle_explicit_torch_failure(error, run_state)`.
+* `_verify_pygranso_stationarity(result)`.
+
+---
+
+## Validation Rules
+
+* CPU target with `auto` selects builtin OSQP.
+* Validated accelerator target with `auto` may select Torch.
+* Unsupported accelerator, oversized KKT, failed Torch solve, or unsolved Torch result under `auto` falls back with warning and causal telemetry.
+* Explicit `torch` never silently changes backend.
+* MPS float64 `auto` requests fall back to builtin CPU OSQP.
+* PyGRANSO steering, penalty updates, B1/B2/B3, stationarity, and termination behavior remain compatible with the existing solver path.
+
+---
+
+## UI / API Integration
+
+* Preserve the public `osqp_algebra` option.
+* Do not add a public `linear_solver` option.
+* Keep legacy CG/CUDA Graph settings on the migration-warning/error path from Phase 1.3.
+* Surface backend/fallback telemetry in existing diagnostic structures where possible.
+
+---
+
+## Workflow
+
+1. BFGS-SQP creates a private Torch OSQP workspace at run initialization.
+2. Each QP subproblem builds a `SolveQPRequest`.
+3. The backend policy selects builtin or Torch.
+4. The selected backend solves or raises.
+5. `auto` Torch failure retries builtin with complete telemetry.
+6. Explicit `torch` failure is returned to PyGRANSO's existing outer fallback/error strategy.
+7. The optimizer records QP telemetry and proceeds through steering, penalty, and termination checks.
+8. End-to-end tests validate final optimization behavior.
+
+---
+
+## Files to Create
+
+* `tests/test_pygranso_torch_osqp_integration.py`: constrained optimization tests for builtin, Torch, and fallback paths.
+
+---
+
+## Files to Modify
+
+* `pygranso/private/bfgssqp.py`: create and own the Torch OSQP workspace.
+* `pygranso/private/solveQP.py`: route requests through the revised backend policy.
+* `pygranso/private/qpSteeringStrategy.py`: add telemetry assertions only if needed.
+* `pygranso/private/qpTerminationCondition.py`: add status handling only if needed.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: record PyGRANSO integration evidence.
+
+---
+
+## Error Handling
+
+* Preserve current PyGRANSO outer fallback behavior.
+* Do not swallow explicit `torch` failures.
+* Warn on automatic builtin fallback and include cause, attempted backend, selected backend, dimensions, dtype, device, and exception/status.
+* Treat numerical failure as numerical failure, not infeasibility.
+
+---
+
+## Testing Checklist
+
+- [x] CPU `auto` path uses builtin OSQP.
+- [x] Explicit `builtin` path remains unchanged.
+- [x] Explicit `torch` path does not silently fall back.
+- [x] Automatic Torch failure retries builtin with causal telemetry.
+- [x] Workspace is created once per BFGS-SQP run.
+- [x] Warm state is reused across compatible QP subproblems.
+- [x] Steering and penalty update tests still pass.
+- [x] B1/B2/B3 behavior remains covered.
+- [x] Complete constrained optimization examples pass with supported backends.
+
+---
+
+## Acceptance Criteria
+
+* PyGRANSO can use the revised Torch-OSQP path through the existing public option.
+* Workspace lifetime is per optimizer run.
+* Automatic fallback and explicit backend behavior are both observable and tested.
+* Complete constrained optimization tests pass for the supported backend matrix.
diff --git a/docs/plans/phase_4.1_tests_and_differential_plan.md b/docs/plans/phase_4.1_tests_and_differential_plan.md
new file mode 100644
index 0000000..3357001
--- /dev/null
+++ b/docs/plans/phase_4.1_tests_and_differential_plan.md
@@ -0,0 +1,291 @@
+# Phase 4.1 Implementation Plan: Test Gates and Differential Validation
+
+## Goal
+
+Implement **deterministic unit, differential, metamorphic, randomized, and PyGRANSO end-to-end validation gates**.
+
+This feature should allow the system to:
+
+1. Prove supported dense Torch-OSQP behavior inside the documented size, dtype, conditioning, and backend matrix.
+2. Compare Torch and builtin OSQP by status compatibility, feasibility, stationarity, residuals, and normalized objective gap.
+3. Run deterministic core tests on every change and broader randomized/stress suites nightly and before release.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* Existing PyGRANSO tests for optimization behavior.
+* Torch-OSQP development requirements in the full pipeline document.
+* A completion audit that tracks which areas still need evidence.
+
+The missing part is:
+
+* A phase-specific test architecture covering solver internals, adapter behavior, and PyGRANSO integration.
+* Reproducible randomized case families with fixed seeds.
+* Explicit release gates for supported support claims.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+TorchOSQPUnitGate
+```
+
+Responsibility:
+
+```text
+Collect deterministic unit tests for validation, KKT assembly, LU reuse, ADMM updates, scaling, adaptive rho, polishing, and workspace invalidation.
+```
+
+### Component 2
+
+```text
+DifferentialGate
+```
+
+Responsibility:
+
+```text
+Run Torch and builtin OSQP with identical settings and compare backend-neutral metrics.
+```
+
+### Component 3
+
+```text
+MetamorphicCaseFamily
+```
+
+Responsibility:
+
+```text
+Generate deterministic equivalent QP transformations that should preserve solution quality and status compatibility.
+```
+
+### Component 4
+
+```text
+PyGRANSOEndToEndGate
+```
+
+Responsibility:
+
+```text
+Validate that the revised QP path preserves steering, stationarity, penalty, fallback, and full optimization behavior.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Unit Gate Registry
+
+```text
++-------------------------------------------------------------------------------+
+|                                TorchOSQPUnitGate                               |
++-------------------------------------------------------------------------------+
+|  - categories: list[string]                                                    |
+|  - requiredOnEveryChange: bool                                                 |
++-------------------------------------------------------------------------------+
+|  + collect(): list[TestModule]            --> unit test modules                |
+|  + run_core(): TestReport                 --> deterministic fast gate          |
+|  + assert_zero_unexplained_failures(): None --> supported-matrix requirement   |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Differential Gate
+
+```text
++-------------------------------------------------------------------------------+
+|                                DifferentialGate                                |
++-------------------------------------------------------------------------------+
+|  - commonSettings: CommonOSQPSettings                                          |
+|  - tolerances: ToleranceSpec                                                   |
+|  - caseFamilies: list[QPCaseFamily]                                            |
++-------------------------------------------------------------------------------+
+|  + solve_both(case): PairResult          --> builtin and Torch results         |
+|  + compare(pair): ComparisonReport       --> backend-neutral metrics           |
+|  + explain_failure(report): string       --> reproducible failure summary      |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Metamorphic Case Family
+
+```text
++-------------------------------------------------------------------------------+
+|                              MetamorphicCaseFamily                             |
++-------------------------------------------------------------------------------+
+|  - baseSeed: int                                                               |
+|  - transformations: list[string]                                               |
++-------------------------------------------------------------------------------+
+|  + generate(seed): QPCase                --> deterministic feasible convex QP  |
+|  + transform(case): list[QPCase]         --> permuted/scaled/equivalent cases  |
+|  + expected_relation(a, b): Relation     --> status/objective feasibility rule |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: PyGRANSO End-to-End Gate
+
+```text
++-------------------------------------------------------------------------------+
+|                              PyGRANSOEndToEndGate                              |
++-------------------------------------------------------------------------------+
+|  - scenarios: list[OptimizationScenario]                                       |
+|  - backends: list[string]                                                      |
++-------------------------------------------------------------------------------+
+|  + run_scenario(scenario, backend): Result --> full optimizer run              |
+|  + check_steering(result): None          --> steering and penalty assertions   |
+|  + check_stationarity(result): None      --> final stationarity assertion      |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Gate classes are conceptual test organization boundaries, not required runtime APIs.
+* Deterministic gates must run quickly enough for every change.
+* Nightly randomized gates must use fixed seeds and write reproducible failure data.
+* Differential tests must not compare raw iterates or iteration counts.
+
+---
+
+## Data Model
+
+```text
+QPCase
+  case_id: string
+  n: int
+  m: int
+  dtype: dtype
+  device: device
+  conditioning_estimate: float
+  P: Tensor
+  q: Tensor
+  A: Tensor
+  l: Tensor
+  u: Tensor
+  seed: int
+```
+
+```text
+TestGateReport
+  gate_name: string
+  backend: string
+  case_count: int
+  passed: int
+  failed: int
+  unexplained_failed: int
+  duration_seconds: float
+  artifact_paths: list[string]
+```
+
+---
+
+## Storage / State
+
+* Store deterministic test cases in test fixtures or generated helper functions.
+* Store nightly artifacts locally until a later release step publishes them.
+* Serialize every randomized failure with input data, settings, seed, platform, and backend.
+* Do not store generated artifacts in source-controlled package paths unless explicitly approved.
+
+---
+
+## Required Methods
+
+* `make_feasible_convex_qp(seed, n, m, dtype, device, conditioning)`.
+* `make_metamorphic_variants(case)`.
+* `run_torch_builtin_differential(case, settings)`.
+* `assert_status_feasibility_stationarity_objective(report)`.
+* `serialize_failure_reproduction(case, result_pair, report)`.
+* `run_pygranso_backend_scenario(scenario, backend)`.
+
+---
+
+## Validation Rules
+
+* Every supported unit category must have deterministic coverage.
+* Nightly family/backend buckets use 100 fixed reproducible seeds.
+* Nightly suites must finish within two hours.
+* Supported cases require zero unexplained failures.
+* Conditioning up to `1e8` is in the supported accuracy target.
+* Cases approaching `1e10` are stress evidence, not guaranteed support.
+* Tests must cover Python 3.10+ with PyTorch 2.8 and the current supported stable PyTorch release.
+
+---
+
+## UI / API Integration
+
+* Integrate deterministic tests into the normal test command or CI path.
+* Integrate stress/randomized gates into nightly and pre-release commands.
+* Expose failure artifact paths in test output.
+* Keep test helpers private to the test suite.
+
+---
+
+## Workflow
+
+1. Run deterministic unit tests for validation, LU, KKT, ADMM, scaling, polishing, workspace, and telemetry.
+2. Run deterministic differential tests under identical builtin/Torch settings.
+3. Run PyGRANSO steering and full optimization scenarios.
+4. Generate nightly randomized and metamorphic cases from fixed seed lists.
+5. Serialize every failure with full reproduction data.
+6. Summarize gate results by backend, dtype, conditioning bucket, and device.
+7. Block promotion or release on unexplained supported-case failures.
+
+---
+
+## Files to Create
+
+* `tests/test_torch_osqp_validation.py`.
+* `tests/test_torch_osqp_linear_solve.py`.
+* `tests/test_torch_osqp_admm.py`.
+* `tests/test_torch_osqp_workspace.py`.
+* `tests/test_torch_osqp_differential.py`.
+* `tests/test_torch_osqp_metamorphic.py`.
+* `tests/test_pygranso_torch_osqp_end_to_end.py`.
+
+---
+
+## Files to Modify
+
+* `tests/conftest.py`: add deterministic seed/device fixtures if needed.
+* `pyproject.toml` or equivalent test configuration: add markers for deterministic, nightly, stress, and hardware gates if needed.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: record gate completion status.
+
+---
+
+## Error Handling
+
+* Any unexplained supported-case failure blocks release.
+* Unsupported hardware should skip with a clear reason, not fail silently.
+* Randomized failures must include serialized reproduction data.
+* Test helpers should fail fast on invalid case generation.
+
+---
+
+## Testing Checklist
+
+- [x] Input validation tests cover NaNs, `l > u`, shape/device/dtype mismatch, and material asymmetry.
+- [x] LU tests cover reuse, refactorization, singular matrices, nonfinite RHS, and RHS shapes.
+- [x] ADMM tests cover KKT assembly, projection, dual updates, residuals, and termination.
+- [x] Scaling/adaptive/polishing tests cover success and failure paths.
+- [x] Workspace invalidation tests cover all documented invalidation triggers.
+- [x] Differential tests compare metrics, not iterates.
+- [x] Metamorphic tests use deterministic equivalent transformations.
+- [x] PyGRANSO tests cover steering, stationarity, penalty updates, B1/B2/B3, fallback, and full constrained runs.
+
+---
+
+## Acceptance Criteria
+
+* Deterministic core tests can run on every change.
+* Nightly randomized/stress suites have fixed seeds and local failure artifacts.
+* Supported cases have zero unexplained failures.
+* Test reports provide enough information to reproduce every failure.
diff --git a/docs/plans/phase_4.2_stability_evidence_plan.md b/docs/plans/phase_4.2_stability_evidence_plan.md
new file mode 100644
index 0000000..b4402c8
--- /dev/null
+++ b/docs/plans/phase_4.2_stability_evidence_plan.md
@@ -0,0 +1,308 @@
+# Phase 4.2 Implementation Plan: Stability Evidence Package
+
+## Goal
+
+Implement **the local stability evidence package for Torch-OSQP validation**.
+
+This feature should allow the system to:
+
+1. Produce case-level CSV results, a JSON manifest, a Markdown summary, and failure reproduction data.
+2. Record commit, platform, hardware, Python, PyTorch, OSQP, backend, settings, and seeds.
+3. Keep artifacts local unless the user explicitly approves publication.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* Planned deterministic and nightly gates in Phase 4.1.
+* Documentation requiring stability evidence outputs.
+* Local workspace authorization to keep artifacts local.
+
+The missing part is:
+
+* A concrete artifact schema.
+* A runner that writes consistent case-level results and summaries.
+* A reproduction bundle for every failure.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+StabilityCaseResult
+```
+
+Responsibility:
+
+```text
+Represent one backend/case outcome with status, metrics, timings, and reproduction pointers.
+```
+
+### Component 2
+
+```text
+StabilityManifest
+```
+
+Responsibility:
+
+```text
+Record environment, commit, platform, hardware, package versions, settings, backends, and seed lists.
+```
+
+### Component 3
+
+```text
+FailureReproductionBundle
+```
+
+Responsibility:
+
+```text
+Serialize all data needed to replay a failed case locally.
+```
+
+### Component 4
+
+```text
+StabilityMarkdownSummary
+```
+
+Responsibility:
+
+```text
+Summarize pass/fail counts, unsupported skips, backend claims, and promotion recommendations.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Case Result
+
+```text
++-------------------------------------------------------------------------------+
+|                               StabilityCaseResult                              |
++-------------------------------------------------------------------------------+
+|  - case_id: string                                                             |
+|  - family: string                                                              |
+|  - backend: string                                                             |
+|  - dtype: string                                                               |
+|  - device: string                                                              |
+|  - kkt_dim: int                                                                |
+|  - conditioning_estimate: float                                                |
+|  - status: string                                                              |
+|  - objective_gap: float                                                        |
+|  - feasibility: float                                                          |
+|  - stationarity: float                                                         |
+|  - reproduction_path: string                                                   |
++-------------------------------------------------------------------------------+
+|  + to_csv_row(): dict                   --> case-level CSV row                 |
+|  + passed_supported_gate(): boolean      --> support-matrix gate               |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Manifest
+
+```text
++-------------------------------------------------------------------------------+
+|                                StabilityManifest                               |
++-------------------------------------------------------------------------------+
+|  - commit: string                                                              |
+|  - platform: dict                                                              |
+|  - hardware: dict                                                              |
+|  - python: string                                                              |
+|  - pytorch: string                                                             |
+|  - osqp: string                                                                |
+|  - backends: list[string]                                                      |
+|  - settings: dict                                                              |
+|  - seeds: dict                                                                 |
++-------------------------------------------------------------------------------+
+|  + collect(): StabilityManifest         --> reads local environment            |
+|  + to_json(): dict                      --> manifest serialization             |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Failure Reproduction Bundle
+
+```text
++-------------------------------------------------------------------------------+
+|                            FailureReproductionBundle                           |
++-------------------------------------------------------------------------------+
+|  - case: QPCase                                                                |
+|  - settings: dict                                                              |
+|  - torch_result: dict                                                          |
+|  - builtin_result: dict                                                        |
+|  - comparison: dict                                                            |
+|  - exception: string                                                           |
++-------------------------------------------------------------------------------+
+|  + write(directory): string             --> serialized reproduction path       |
+|  + replay(): ComparisonReport           --> optional local replay helper       |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: Markdown Summary
+
+```text
++-------------------------------------------------------------------------------+
+|                            StabilityMarkdownSummary                            |
++-------------------------------------------------------------------------------+
+|  - manifest: StabilityManifest                                                 |
+|  - case_results: list[StabilityCaseResult]                                     |
++-------------------------------------------------------------------------------+
+|  + aggregate(): dict                    --> counts by backend/family/bucket    |
+|  + recommendations(): list[string]      --> support promotion notes            |
+|  + render(): string                     --> Markdown summary                   |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Artifact writers should be deterministic for fixed inputs and seed order.
+* Evidence generation should not change solver behavior.
+* Failure bundles must avoid secrets and must not include unrelated local paths.
+* Stability artifacts are local outputs, not package source files.
+
+---
+
+## Data Model
+
+```text
+torch_osqp_stability_results.csv
+  case_id
+  family
+  seed
+  backend
+  dtype
+  device
+  n
+  m
+  kkt_dim
+  conditioning_estimate
+  status
+  feasibility
+  stationarity
+  objective_gap
+  runtime_seconds
+  passed
+  failure_reason
+  reproduction_path
+```
+
+```text
+stability_manifest.json
+  commit
+  platform
+  hardware
+  python
+  pytorch
+  osqp
+  numpy
+  backend
+  settings
+  seeds
+  command
+```
+
+---
+
+## Storage / State
+
+* Store generated outputs under a local artifact directory such as `artifacts/torch_osqp_stability/<timestamp>/`.
+* Keep reproduction bundles next to the manifest and CSV.
+* Do not commit generated evidence unless a release process explicitly requests it.
+* Keep case data small enough for local reproduction and review.
+
+---
+
+## Required Methods
+
+* `collect_stability_manifest(backends, settings, seeds)`.
+* `run_stability_case(case, backend, settings)`.
+* `write_case_results_csv(results, path)`.
+* `write_manifest_json(manifest, path)`.
+* `write_failure_reproduction(case, results, exception, path)`.
+* `render_stability_summary(manifest, results)`.
+
+---
+
+## Validation Rules
+
+* CSV rows must include every required field.
+* Manifest must include commit, platform, hardware, Python, PyTorch, OSQP, backend, settings, and seeds.
+* Every failed supported case must have a reproduction bundle.
+* Summary counts must match CSV row counts.
+* Supported size gate remains `n+m <= 2400`.
+* Artifacts remain local unless publication is explicitly approved.
+
+---
+
+## UI / API Integration
+
+* Provide a script or pytest command for local evidence generation.
+* Emit artifact paths at the end of the run.
+* Keep generated evidence out of normal imports.
+* Keep the evidence runner backend-aware so support claims can be promoted independently.
+
+---
+
+## Workflow
+
+1. Collect manifest metadata.
+2. Generate deterministic case families and seed lists.
+3. Run each case/backend bucket.
+4. Write one CSV row per case/backend result.
+5. Serialize reproduction data for every failure.
+6. Render the Markdown summary.
+7. Review support claims based on zero unexplained supported-case failures.
+
+---
+
+## Files to Create
+
+* `scripts/torch_osqp_stability.py`: local evidence runner.
+* `tests/test_torch_osqp_stability_artifacts.py`: artifact schema tests.
+
+---
+
+## Files to Modify
+
+* `.gitignore`: ignore local stability artifact directories if not already covered.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: summarize evidence status and artifact paths.
+* `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`: reference the evidence package command after implementation.
+
+---
+
+## Error Handling
+
+* Continue running independent cases after a case failure.
+* Mark unsupported backend/device combinations as skipped with reason.
+* Fail the evidence command when a supported bucket has unexplained failures.
+* Write partial artifacts when the run is interrupted after cases have completed.
+
+---
+
+## Testing Checklist
+
+- [x] CSV schema contains all required columns.
+- [x] Manifest schema contains environment, backend, settings, and seed data.
+- [x] Failure reproduction bundle is written for every failure.
+- [x] Markdown summary totals match CSV data.
+- [x] Unsupported backend skips include explicit reasons.
+- [x] Local artifact directory is ignored or clearly excluded from release commits.
+
+---
+
+## Acceptance Criteria
+
+* Evidence generation produces the required CSV, JSON manifest, Markdown summary, and failure bundles.
+* Artifacts remain local by default.
+* Support promotion decisions can be traced to case-level evidence.
diff --git a/docs/plans/phase_4.3_platform_promotion_plan.md b/docs/plans/phase_4.3_platform_promotion_plan.md
new file mode 100644
index 0000000..0d77353
--- /dev/null
+++ b/docs/plans/phase_4.3_platform_promotion_plan.md
@@ -0,0 +1,285 @@
+# Phase 4.3 Implementation Plan: Platform Gates and Backend Promotion
+
+## Goal
+
+Implement **backend-by-backend platform support gates and promotion policy**.
+
+This feature should allow the system to:
+
+1. Promote CPU, CUDA, ROCm, and MPS support independently.
+2. Require real hardware evidence before claiming accelerator support.
+3. Enforce conservative size, memory, accuracy, and performance gates before `auto` selects an accelerator backend.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* Backend policy requirements for CPU, CUDA, ROCm, and MPS.
+* A support matrix requirement in the full pipeline document.
+* Planned stability evidence outputs from Phase 4.2.
+
+The missing part is:
+
+* A concrete backend promotion record and support matrix workflow.
+* Real-hardware gates for claimed accelerator support.
+* Runtime policy checks that match the documented promotion state.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+SupportMatrixEntry
+```
+
+Responsibility:
+
+```text
+Represent one backend/dtype/device support claim and the evidence required for promotion.
+```
+
+### Component 2
+
+```text
+BackendPromotionRecord
+```
+
+Responsibility:
+
+```text
+Capture test, stability, hardware, and performance results that justify one backend promotion decision.
+```
+
+### Component 3
+
+```text
+HardwareRunnerGate
+```
+
+Responsibility:
+
+```text
+Ensure claimed accelerator support is validated on real hardware, not inferred from CPU-only tests.
+```
+
+### Component 4
+
+```text
+AutoPromotionPerformanceGate
+```
+
+Responsibility:
+
+```text
+Require representative end-to-end median runtime no worse than 5x builtin CPU OSQP before auto-promoting an accelerator.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Support Matrix Entry
+
+```text
++-------------------------------------------------------------------------------+
+|                               SupportMatrixEntry                               |
++-------------------------------------------------------------------------------+
+|  - backend: string                                                             |
+|  - device: string                                                              |
+|  - dtype: string                                                               |
+|  - claimed: bool                                                               |
+|  - autoEligible: bool                                                          |
+|  - maxKktDim: int                                                              |
+|  - accuracyConditioningLimit: float                                            |
+|  - evidencePath: string                                                        |
++-------------------------------------------------------------------------------+
+|  + can_select_auto(request): boolean    --> runtime auto-selection eligibility |
+|  + reason_if_blocked(request): string   --> fallback/skip explanation          |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Promotion Record
+
+```text
++-------------------------------------------------------------------------------+
+|                              BackendPromotionRecord                            |
++-------------------------------------------------------------------------------+
+|  - supportEntry: SupportMatrixEntry                                            |
+|  - stabilitySummaryPath: string                                                |
+|  - hardwareDescription: dict                                                   |
+|  - performanceRatio: float                                                     |
+|  - unexplainedFailures: int                                                    |
++-------------------------------------------------------------------------------+
+|  + eligible_for_claim(): boolean        --> documentation support claim        |
+|  + eligible_for_auto(): boolean         --> runtime auto-promotion decision    |
+|  + render_decision_log(): string        --> human-readable promotion note      |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Hardware Runner Gate
+
+```text
++-------------------------------------------------------------------------------+
+|                                HardwareRunnerGate                              |
++-------------------------------------------------------------------------------+
+|  - backend: string                                                             |
+|  - requiredHardware: string                                                    |
+|  - workflowName: string                                                        |
++-------------------------------------------------------------------------------+
+|  + detect(): HardwareInfo                --> records actual runner hardware    |
+|  + run_required_tests(): GateReport      --> backend-specific validation       |
+|  + skip_reason(): string                 --> explicit unclaimed-backend reason |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: Performance Gate
+
+```text
++-------------------------------------------------------------------------------+
+|                            AutoPromotionPerformanceGate                        |
++-------------------------------------------------------------------------------+
+|  - baselineBackend: string = builtin_cpu                                      |
+|  - maxMedianRatio: float = 5.0                                                 |
++-------------------------------------------------------------------------------+
+|  + benchmark(caseSet): PerformanceReport --> includes transfers                |
+|  + passes(report): boolean              --> median runtime <= 5x baseline     |
+|  + memory_preflight(request): boolean    --> conservative dense memory check   |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Documentation support claims and runtime `auto` eligibility are related but distinct decisions.
+* Promotion must be independent per backend and dtype.
+* Accelerator claims require real hardware evidence.
+* MPS float64 is not an auto target; it falls back to builtin CPU OSQP.
+
+---
+
+## Data Model
+
+```text
+SupportMatrix
+  entries: list[SupportMatrixEntry]
+  generated_from: list[BackendPromotionRecord]
+  last_updated: date
+```
+
+```text
+PerformanceReport
+  backend: string
+  baseline_backend: string
+  case_set: string
+  median_runtime_seconds: float
+  baseline_median_runtime_seconds: float
+  median_ratio: float
+  includes_transfers: bool
+  memory_preflight_passed: bool
+```
+
+---
+
+## Storage / State
+
+* Store support matrix in documentation and runtime constants only after evidence review.
+* Store promotion records with local evidence artifacts or release documentation.
+* Keep unclaimed backends explicitly documented as unclaimed.
+* Do not promote based on simulated or unavailable hardware.
+
+---
+
+## Required Methods
+
+* `_accelerator_capability(device, dtype, support_matrix)`.
+* `_memory_preflight(n, m, dtype, device)`.
+* `_auto_backend_eligible(request, support_matrix)`.
+* `collect_hardware_info()`.
+* `run_backend_promotion_gate(backend, dtype, device)`.
+* `render_support_matrix(records)`.
+
+---
+
+## Validation Rules
+
+* CPU Torch tests must run on Linux, Windows, and macOS before CPU support is complete.
+* CUDA is initially eligible for promotion after real-runner evidence.
+* ROCm remains unclaimed until a real runner is obtained.
+* MPS float32 remains unclaimed until reusable LU passes on real Apple hardware.
+* MPS float64 `auto` requests fall back to builtin CPU OSQP.
+* `auto` accelerator selection requires `n+m <= 2400`, memory preflight pass, support claim, and median runtime no worse than 5x builtin CPU OSQP.
+
+---
+
+## UI / API Integration
+
+* Runtime backend policy reads the support matrix to decide `auto` eligibility.
+* Documentation support matrix mirrors the runtime support matrix.
+* Fallback telemetry includes unsupported/unclaimed reason codes.
+* Performance reports include transfer time.
+
+---
+
+## Workflow
+
+1. Run deterministic CPU Torch tests on Linux, Windows, and macOS.
+2. Run real-hardware gates for each accelerator candidate.
+3. Run stability evidence buckets for backend/dtype/device combinations.
+4. Run representative end-to-end performance comparisons including transfers.
+5. Produce promotion records.
+6. Promote only backend entries with complete evidence.
+7. Update runtime support matrix and documentation.
+8. Keep unclaimed backends unselected by `auto`.
+
+---
+
+## Files to Create
+
+* `tests/test_torch_osqp_support_matrix.py`: support matrix and auto-eligibility tests.
+* `scripts/torch_osqp_backend_promotion.py`: optional local promotion summary helper.
+
+---
+
+## Files to Modify
+
+* `pygranso/private/solveQP.py`: align auto-selection policy with support matrix.
+* `pygranso/private/torchOSQP.py`: expose device/dtype diagnostics required by promotion checks if needed.
+* `.github/workflows/`: add or update backend gate workflows when CI is configured.
+* `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`: update support matrix and promotion policy.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: record promotion decisions.
+
+---
+
+## Error Handling
+
+* Unsupported or unclaimed hardware falls back under `auto` with a clear reason.
+* Explicit `torch` on unsupported hardware raises or fails visibly according to adapter policy.
+* Missing hardware evidence blocks support claims.
+* Failed performance gate blocks `auto` promotion even when correctness tests pass.
+
+---
+
+## Testing Checklist
+
+- [x] Support matrix rejects unclaimed ROCm by default.
+- [x] MPS float64 `auto` falls back to builtin CPU OSQP.
+- [x] Oversized KKT dimensions block `auto` accelerator selection.
+- [x] Memory preflight failure blocks `auto` accelerator selection.
+- [x] Explicit `torch` does not silently fallback.
+- [x] Performance gate uses runtime including transfers.
+- [x] Documentation and runtime support matrix stay synchronized.
+
+---
+
+## Acceptance Criteria
+
+* Backend support is promoted independently and only with evidence.
+* Runtime `auto` selection follows the support matrix.
+* Accelerator auto-promotion requires correctness, real hardware, size/memory checks, and performance evidence.
diff --git a/docs/plans/phase_5.1_documentation_pdf_release_plan.md b/docs/plans/phase_5.1_documentation_pdf_release_plan.md
new file mode 100644
index 0000000..3dee0a9
--- /dev/null
+++ b/docs/plans/phase_5.1_documentation_pdf_release_plan.md
@@ -0,0 +1,290 @@
+# Phase 5.1 Implementation Plan: Documentation, PDF, and Release Evidence
+
+## Goal
+
+Implement **the final documentation, PDF, audit, and release-evidence update**.
+
+This feature should allow the system to:
+
+1. Maintain a two-part document: reviewer executive summary plus decision-complete engineering specification.
+2. Preserve mathematically correct KKT, ADMM, projection, dual-update, and residual equations.
+3. Attach support matrix, risk table, decision log, evidence links, and code-edit reports to release work.
+
+Keep the implementation modular, easy to test, and consistent with the existing project structure.
+
+---
+
+## Current State
+
+The project already has:
+
+* `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`.
+* Related documentation in `UNCONSTRAINED_AND_OSQP.md`, `MIXED_PRECISION.md`, and `TORCH_COMPILE.md`.
+* Local generated plans under `docs/plans/`.
+
+The missing part is:
+
+* A final release-ready documentation pass after implementation evidence exists.
+* A reproducible PDF generation path with controlled page breaks for code blocks and diagrams.
+* Cross-links from plans, audit, evidence, and code-edit reports.
+
+---
+
+## New Components to Add
+
+### Component 1
+
+```text
+DocumentationSourceSet
+```
+
+Responsibility:
+
+```text
+Track source Markdown documents that define the release narrative, engineering decisions, and support claims.
+```
+
+### Component 2
+
+```text
+RenderedPDFArtifact
+```
+
+Responsibility:
+
+```text
+Represent the generated PDF, including source revision, render command, output path, and visual checks.
+```
+
+### Component 3
+
+```text
+CompletionAuditEntry
+```
+
+Responsibility:
+
+```text
+Record implementation status, validation evidence, residual risks, and support-matrix decisions.
+```
+
+### Component 4
+
+```text
+CodeEditReportEntry
+```
+
+Responsibility:
+
+```text
+Record every code or code-adjacent project change with timing, validation, findings, and required human action.
+```
+
+---
+
+## Class / Registry Diagrams
+
+### Diagram 1: Documentation Source Set
+
+```text
++-------------------------------------------------------------------------------+
+|                              DocumentationSourceSet                            |
++-------------------------------------------------------------------------------+
+|  - pipelineDoc: path                                                           |
+|  - auditDoc: path                                                              |
+|  - relatedDocs: list[path]                                                     |
+|  - planDirectory: path                                                         |
++-------------------------------------------------------------------------------+
+|  + validate_links(): LinkReport          --> local doc cross-link check        |
+|  + validate_claims(evidence): ClaimReport --> support claims match evidence    |
+|  + release_index(): dict                 --> docs included in release review   |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 2: Rendered PDF Artifact
+
+```text
++-------------------------------------------------------------------------------+
+|                              RenderedPDFArtifact                               |
++-------------------------------------------------------------------------------+
+|  - sourcePath: path                                                            |
+|  - outputPath: path                                                            |
+|  - renderCommand: string                                                       |
+|  - generatedAt: datetime                                                       |
+|  - pageCount: int                                                              |
++-------------------------------------------------------------------------------+
+|  + render(): path                        --> generates local PDF               |
+|  + inspect_layout(): LayoutReport        --> page breaks/code block checks     |
+|  + checksum(): string                    --> release artifact identity         |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 3: Completion Audit Entry
+
+```text
++-------------------------------------------------------------------------------+
+|                              CompletionAuditEntry                              |
++-------------------------------------------------------------------------------+
+|  - phase: string                                                               |
+|  - status: string                                                              |
+|  - evidencePaths: list[path]                                                   |
+|  - risks: list[string]                                                         |
+|  - decisions: list[string]                                                     |
++-------------------------------------------------------------------------------+
+|  + update_from_phase(phase): None       --> records implementation status      |
+|  + verify_evidence_exists(): boolean    --> checks local artifact paths        |
+|  + render_summary(): string             --> audit Markdown section             |
++-------------------------------------------------------------------------------+
+```
+
+### Diagram 4: Code Edit Report Entry
+
+```text
++-------------------------------------------------------------------------------+
+|                                CodeEditReportEntry                             |
++-------------------------------------------------------------------------------+
+|  - goal: string                                                                |
+|  - timing: string                                                              |
+|  - changedFiles: list[path]                                                    |
+|  - findings: list[string]                                                      |
+|  - validation: list[string]                                                    |
+|  - humanAction: list[string]                                                   |
++-------------------------------------------------------------------------------+
+|  + append(logPath): None                --> repository work-session memory     |
+|  + summarize_for_release(): string      --> release-note input                 |
++-------------------------------------------------------------------------------+
+```
+
+---
+
+## Class Diagram Rules
+
+* Documentation source files remain Markdown-first.
+* The generated PDF is an artifact, not the source of truth.
+* Support claims must be evidence-backed.
+* Code-edit reports remain separate from required human action and reflection.
+
+---
+
+## Data Model
+
+```text
+ReleaseDocumentationIndex
+  version: string
+  date: date
+  pipeline_doc: path
+  audit_doc: path
+  support_matrix: path
+  stability_artifacts: list[path]
+  pdf_artifact: path
+  code_edit_log: path
+```
+
+```text
+LayoutReport
+  page_count: int
+  broken_code_blocks: int
+  broken_diagrams: int
+  missing_toc: bool
+  missing_page_breaks: list[string]
+```
+
+---
+
+## Storage / State
+
+* Store source documentation in `docs/`.
+* Store phase plans in `docs/plans/`.
+* Store local PDF/evidence outputs in a local artifact directory unless release policy approves committing them.
+* Store code-edit reports in `.codex/code-edit-log.md`.
+
+---
+
+## Required Methods
+
+* `validate_documentation_links(docs_dir)`.
+* `validate_support_claims_against_evidence(audit_doc, evidence_dir)`.
+* `render_pipeline_pdf(source, output)`.
+* `inspect_pdf_layout(pdf_path)`.
+* `update_completion_audit(phase, status, evidence)`.
+* `append_code_edit_report(entry)`.
+
+---
+
+## Validation Rules
+
+* The final pipeline document must include version/date, table of contents, support matrix, risk table, decision log, and controlled page breaks.
+* Torch-direct must be described as a dense reference implementation, not a scalable sparse solver.
+* Infeasibility certificates, nonconvex detection, and sparse acceleration remain later milestones.
+* Public behavior must preserve `osqp_algebra={"auto","builtin","torch"}`.
+* PDF layout must be visually checked when generated.
+* Every implementation task that modifies project files must append a code-edit report.
+
+---
+
+## UI / API Integration
+
+* No runtime API changes are expected in this documentation phase.
+* Documentation must describe actual runtime behavior from earlier phases.
+* Release notes should link to local evidence summaries when available.
+
+---
+
+## Workflow
+
+1. Confirm implementation and evidence status for each phase.
+2. Update the completion audit with evidence paths, risks, and decisions.
+3. Update the full pipeline document with final support claims and release gates.
+4. Validate local documentation links.
+5. Render the PDF locally.
+6. Inspect PDF layout for table of contents, code blocks, diagrams, and page breaks.
+7. Write release summary and code-edit report entries.
+8. Keep generated artifacts local unless the human approves publication.
+
+---
+
+## Files to Create
+
+* `scripts/render_torch_osqp_pipeline_pdf.py`: optional reproducible PDF rendering helper if no existing doc build path fits.
+* `tests/test_torch_osqp_docs_links.py`: optional documentation link and claim checks.
+
+---
+
+## Files to Modify
+
+* `docs/FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md`: final engineering specification and reviewer summary.
+* `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: phase status, evidence, risk, and decision updates.
+* `docs/plans/README.md`: release-phase references if the plan index changes.
+* `.codex/code-edit-log.md`: append code-edit reports for documentation and implementation edits.
+
+---
+
+## Error Handling
+
+* Missing evidence blocks support claims.
+* Broken local documentation links block release documentation completion.
+* PDF rendering failure leaves Markdown as source of truth and records the issue in the audit.
+* Layout failures require doc edits before the PDF is considered release-ready.
+
+---
+
+## Testing Checklist
+
+- [x] Full pipeline document has reviewer summary and engineering specification.
+- [x] KKT, ADMM, projection, dual-update, and residual equations are preserved.
+- [x] Support matrix matches backend evidence.
+- [x] Risk table and decision log are current.
+- [x] Local plan links resolve.
+- [x] PDF renders successfully when requested.
+- [x] PDF layout is visually checked for code blocks, diagrams, and page breaks.
+- [x] Code-edit report exists for every implementation task that modifies files.
+
+---
+
+## Acceptance Criteria
+
+* Documentation accurately reflects the implemented dense Torch reference solver.
+* Release support claims are evidence-backed and backend-specific.
+* Generated artifacts remain local unless explicitly approved.
+* The completion audit and code-edit log provide a clear release trail.
diff --git a/docs/plans/phase_5.2_fork_local_hardening_plan.md b/docs/plans/phase_5.2_fork_local_hardening_plan.md
new file mode 100644
index 0000000..9759ae9
--- /dev/null
+++ b/docs/plans/phase_5.2_fork_local_hardening_plan.md
@@ -0,0 +1,238 @@
+# Phase 5.2 Implementation Plan: Fork-Local Release Candidate Hardening
+
+## Goal
+
+Implement **fork-local release candidate hardening**.
+
+This step should allow us to:
+
+1. Treat the fork, not the original repo PR, as the active validation target.
+2. Cleanly separate “project quality is good enough” from “upstream PR is ready.”
+3. Verify the forked project through repeatable local/fork evidence before any future PR decision.
+
+Keep this documentation/test-focused, conservative, and consistent with the current roadmap.
+
+## Current State
+
+The project already has:
+
+- `docs/plans/roadmap.md`: main checkbox/status source.
+- `docs/TORCH_OSQP_COMPLETION_AUDIT.md`: current release audit.
+- `.github/workflows/torch-osqp-core.yml`: deterministic core CI.
+- `.github/workflows/torch-osqp-nightly.yml`: CPU nightly stability gate.
+- `.github/workflows/torch-osqp-cuda-promotion.yml`: CUDA promotion gate, still unpromoted.
+- `scripts/render_pipeline_pdf.py`: pipeline PDF renderer.
+- `tests/`: deterministic, OSQP, PyGRANSO, metamorphic, randomized, and reporting tests.
+- `F:\UMN Researches\Ju Research\Report`: external research notebook and artifact storage.
+
+Current evidence:
+
+- Fork `main` core CI passed.
+- Fork `main` nightly CPU stability passed.
+- 1800 CPU cases, 0 release-gate failures.
+- CUDA remains unpromoted.
+- ROCm/MPS remain unclaimed.
+- Local full pytest is blocked by a local temp-directory permission issue, but 71 tests passed and the affected reporting behavior was separately smoke-tested.
+
+The missing part is:
+
+- Roadmap/audit wording still frames upstream PR/review as an active release action.
+- We need a fork-local “good enough” checklist.
+- We need one more clean local/fork release-candidate review that does not depend on the original repo.
+
+## New Components to Add
+
+No new production solver components should be added in this phase.
+
+Optional only:
+
+### Component 1
+
+`ForkReleaseCandidateChecklist`
+
+Responsibility:
+
+A lightweight checklist, likely documented rather than coded, that records fork-local readiness checks, evidence locations, known limitations, and final “do not promote accelerators yet” status.
+
+Skip this component if the existing `Report` tracker is enough.
+
+## Class / Registry Diagrams
+
+### Stateless Utility / Checklist
+
+```text
++-------------------------------------------------------------------------------+
+|                         ForkReleaseCandidateChecklist                          |
++-------------------------------------------------------------------------------+
+|  - No persistent internal state                                                |
++-------------------------------------------------------------------------------+
+|  + inspect_repo_state(): Report              --> Confirms clean local branch    |
+|  + verify_fork_ci(): Report                  --> Checks fork core/nightly runs  |
+|  + verify_artifacts(): Report                --> Aggregates CSV/manifest data   |
+|  + run_local_smoke_tests(): Report           --> Runs meaningful local tests    |
+|  + classify_blockers(): Report               --> Separates local/fork/upstream  |
++-------------------------------------------------------------------------------+
+```
+
+## Class Diagram Rules
+
+1. Do not add production classes for this phase.
+2. Keep this phase documentation/test-only unless an actual repeated manual check needs scripting.
+3. If a helper script is added later, make it stateless.
+4. Do not expose any user-facing API.
+5. Do not modify solver math or backend behavior.
+
+## Data Model
+
+This phase does not need persistent project data.
+
+Use a simple evidence record shape in the Report notebook:
+
+```python
+ReleaseCandidateEvidence = {
+    "repo": str,
+    "branch": str,
+    "commit": str,
+    "core_run": str,
+    "nightly_run": str,
+    "total_cases": int,
+    "release_gate_failures": int,
+    "known_limitations": list[str],
+    "next_required_human_action": str,
+}
+```
+
+## Storage / State
+
+Temporary / external state only.
+
+- Repo files: only modify if roadmap/audit wording needs to reflect fork-local strategy.
+- External notebook: continue using `F:\UMN Researches\Ju Research\Report`.
+- Artifacts: keep local in `Report`, not committed.
+
+## Required Methods
+
+No code methods required now.
+
+Operational commands/checks:
+
+```powershell
+git status --short --branch
+gh run view <fork-core-run> --repo Ztang-Yit-Xiaang/PyGRANSO
+gh run view <fork-nightly-run> --repo Ztang-Yit-Xiaang/PyGRANSO
+python -m pytest tests -q
+python scripts/render_pipeline_pdf.py   # only if docs change
+```
+
+If local pytest temp permissions fail again, record it and use:
+
+```powershell
+python -m pytest tests -q -p no:cacheprovider -k "not test_time_limit_exit_writes_partial_artifacts"
+```
+
+plus the direct reporting smoke test.
+
+## Validation Rules
+
+Before marking this phase done:
+
+1. Fork `main` must be the validation target.
+2. No upstream/original PR work should be performed.
+3. CPU evidence must show 0 release-gate failures.
+4. Float64 remains authoritative.
+5. Float32 remains qualified.
+6. CUDA remains unpromoted.
+7. ROCm/MPS remain unclaimed.
+8. Local test limitations must be classified as environment issues only when CI evidence covers the same logic.
+9. Any roadmap/audit edit must avoid marking future or hardware-gated items complete.
+
+## UI / API Integration
+
+No UI/API integration.
+
+Internal callers are human/Codex release workflow steps:
+
+- Input: repo state, fork CI runs, artifact CSVs/manifests, roadmap/audit files.
+- Output: local readiness summary and clear next blocker classification.
+- Errors: missing artifacts, failed fork CI, unsupported accelerator evidence, dirty repo, local temp permission limitations.
+
+## Workflow
+
+1. Inspect local repo cleanliness.
+2. Inspect fork `main` status and latest validation runs.
+3. Aggregate latest fork-main nightly artifacts.
+4. Run local deterministic tests where meaningful.
+5. Classify local failures as either:
+   - real project blocker,
+   - local environment issue,
+   - non-gating stress evidence.
+6. Review roadmap/audit wording.
+7. If docs still over-focus on upstream PR, revise wording to say upstream is future handoff, not current active path.
+8. Regenerate PDF only if the main pipeline doc changes.
+9. Update `.codex/code-edit-log.md` if repo files change.
+10. Update external Report tracker.
+11. Stop before any original/upstream PR action.
+
+## Files to Create
+
+Only if useful:
+
+- `F:\UMN Researches\Ju Research\Report\YYYY-MM-DD_fork_release_candidate_readiness.md`
+
+Do not create new repo files unless we decide the roadmap/audit needs strategy clarification.
+
+## Files to Modify
+
+Possibly:
+
+- `docs/plans/roadmap.md`
+- `docs/TORCH_OSQP_COMPLETION_AUDIT.md`
+- `.codex/code-edit-log.md`
+
+Do not modify solver source in this phase.
+
+## Error Handling
+
+Handle:
+
+- Fork CI failed: classify as blocker and inspect logs.
+- Missing artifacts: rerun/download fork nightly.
+- Local pytest temp issue: document environment limitation, use fork CI as authoritative, run partial local coverage.
+- Dirty repo: inspect before any edit.
+- Accelerator evidence missing: keep CUDA/ROCm/MPS unpromoted/unclaimed.
+- Original repo PR temptation: skip; not in scope.
+
+## Testing Checklist
+
+- [x] `git status --short --branch` is clean before and after.
+- [x] Fork `main` core run is still successful.
+- [x] Fork `main` nightly run is still successful.
+- [x] Latest artifact CSVs aggregate to 1800 cases and 0 release-gate failures.
+- [x] Manifests show clean source, no timeout, no partial results.
+- [x] Local deterministic tests are attempted.
+- [x] Local environment-only failures are documented clearly.
+- [x] Roadmap/audit do not overclaim accelerator support.
+- [x] No original/upstream PR action is performed.
+- [x] Report tracker is updated.
+
+## Roadmap / Full Pipeline Update
+
+If implementing this phase changes repo docs:
+
+- Update roadmap/audit wording minimally.
+- Do not check upstream merge/register tasks.
+- Do not check CUDA/ROCm/MPS promotion tasks.
+- Add a note that fork-local readiness is the active path before any future PR decision.
+
+## Acceptance Criteria
+
+This phase is complete when:
+
+1. Fork-local release readiness is clearly defined.
+2. Fork `main` evidence is verified and summarized.
+3. Local test limitations are classified accurately.
+4. Roadmap/audit wording matches your instruction: no active original repo PR work.
+5. No accelerator support is overclaimed.
+6. External Report tracker has the final checkpoint.
+7. The repo remains clean.
+8. The next blocker is either a real technical failure or a human decision to proceed toward PR later.
diff --git a/docs/plans/roadmap.md b/docs/plans/roadmap.md
new file mode 100644
index 0000000..14b9e8e
--- /dev/null
+++ b/docs/plans/roadmap.md
@@ -0,0 +1,1046 @@
+# PyGRANSO Torch-OSQP Full Development and Validation Pipeline Roadmap
+
+Project Name: PyGRANSO Torch-OSQP Dense Reference Route
+Version: 2.2
+Date: 2026-07-04
+Status: Release-candidate roadmap; dense CPU path implemented/evidenced, accelerator promotion still gated
+
+This roadmap applies the full development and validation template to the current
+PyGRANSO Torch-OSQP project. It uses the repository's existing phase files and
+does not create new phase numbering unless the implementation scope changes.
+
+The detailed phase plans are linked from the milestone roadmap in Section 20.
+
+---
+
+## Part I - Executive Summary
+
+### 1. Decision
+
+Build a correctness-first, Torch-native dense OSQP reference route for PyGRANSO.
+
+This implementation is:
+
+* correctness-first;
+* PyTorch-native;
+* dense reference, not sparse/scalable;
+* not claimed as primal-infeasibility, dual-infeasibility, nonconvex-detection, or sparse large-scale support yet;
+* designed so future Torch/sparse/vendor backends can fit behind the same internal factorize/solve interface.
+
+The first trustworthy milestone supports feasible convex QPs in OSQP form:
+
+```text
+minimize    0.5 * x' P x + q' x
+subject to  l <= A x <= u
+```
+
+The implementation is judged by observable outcomes:
+
+* compatible status;
+* feasibility;
+* stationarity;
+* primal/dual residuals;
+* normalized objective gap;
+* structured backend, fallback, linear-solve, and stability diagnostics.
+
+It does not require identical ADMM trajectories, raw iterates, iteration counts,
+rho histories, or low-level runtime behavior across devices/backends.
+
+### 2. Primary Acceptance Envelope
+
+| Item | Supported Contract |
+| --- | --- |
+| Problem class | Feasible convex QPs in OSQP form |
+| Authoritative precision | float64 |
+| Qualified precision | float32 with `1e-5` tolerances and observed conditioning around `1e2` |
+| Size limit | Dense KKT dimension `n + m <= 2400` for automatic Torch selection |
+| Float64 supported conditioning | Estimated KKT conditioning approximately `1e8` |
+| Stress-only conditioning | Estimated KKT conditioning approaching `1e10` |
+| Linear algebra | Reusable `torch.linalg.lu_factor_ex` and `torch.linalg.lu_solve` |
+| Required numerical features | Ruiz scaling, adaptive rho, polishing, warm starts |
+| Default CPU policy | Builtin OSQP |
+| Default accelerator policy | Torch only after backend-specific promotion gates pass |
+| Failure budget | Zero unexplained failures inside the supported size/dtype/conditioning/device matrix |
+
+### 3. Backend / Platform Support Matrix
+
+| Backend / Platform | Precision | Current Status | Promotion Evidence Required |
+| --- | --- | --- | --- |
+| Torch CPU on Linux | float32/float64 | Release-gated; core workflow evidence exists | Core, nightly, and end-to-end release evidence |
+| Torch CPU on Windows | float32/float64 | Local manifest-backed correctness evidence exists | Release review of local/CI evidence |
+| Torch CPU on macOS | float32/float64 | Release-gated; core workflow evidence exists | Core, nightly, and end-to-end release evidence |
+| NVIDIA CUDA | float32/float64 | Unpromoted | Current-source real hardware correctness plus median end-to-end runtime no worse than 5x builtin CPU OSQP |
+| AMD ROCm | float32/float64 | Unclaimed | Real-hardware runner and full evidence package |
+| Apple MPS | float32 only | Unclaimed | Real Apple hardware reusable-LU evidence |
+| Apple MPS float64 | Unsupported for Torch tensors | `auto` returns builtin CPU result | No Torch support claim |
+| Sparse/direct/vendor backends | Not in first milestone | Future work | Same internal interface plus backend-specific evidence |
+
+### 4. Outcome Policy
+
+The default `auto` policy follows the requested optimization device:
+
+* CPU work uses builtin OSQP.
+* Accelerator work uses Torch only when the backend is promoted, the KKT size
+  is inside the envelope, memory preflight passes, correctness evidence exists,
+  and the performance sanity gate passes.
+* Unsupported, unpromoted, oversized, memory-risky, failed, or unsolved Torch
+  routes under `auto` produce warned builtin fallback with causal telemetry.
+* Explicit `torch` requests never silently change backend. Above the supported
+  size envelope they warn and attempt as requested; hard failures propagate to
+  PyGRANSO's existing outer fallback strategy.
+
+Automatic fallback must be:
+
+* visible;
+* warned;
+* structured;
+* reproducible;
+* stored in diagnostics.
+
+### 5. Main Risks and Controls
+
+| Risk | Control |
+| --- | --- |
+| Repeated dense refactorization | Cache LU factors and rebuild only when KKT-affecting data changes |
+| Dense memory growth | `n + m <= 2400` auto limit plus conservative memory preflight |
+| Precision instability | Float64 authoritative path; dtype-aware tolerances; condition-aware float32 claims |
+| Hidden fallback | Runtime warning plus structured telemetry |
+| Cross-run contamination | One private `TorchOSQPWorkspace` per BFGS-SQP run |
+| Misclassified numerical failure | Never report LU/numerical failure as infeasibility |
+| Optional polishing corrupts solution | Accept only nonworse/tolerance-satisfying candidates; requested failure raises |
+| Unsupported accelerator claims | Promote backend-by-backend only after evidence |
+| Workflow unavailable before merge | Keep feature-branch workflows configured but not claimed until registered on default branch |
+
+---
+
+## Part II - Decision-Complete Engineering Specification
+
+### 6. Architecture
+
+```text
+PyGRANSO BFGS-SQP
+  -> steering QP or stationarity QP
+  -> pygranso/private/solveQP.py
+  -> pygranso/private/osqpTorchAdapter.py
+  -> canonical P, q, A_osqp, l, u
+     -> builtin CPU OSQP
+     -> dense Torch OSQP reference
+        -> OSQP ADMM equations
+        -> private DenseLUSolver boundary
+        -> reusable PyTorch LU factorization and repeated solves
+```
+
+The low-level solver boundary is internal.
+
+User-facing backend selector:
+
+```text
+osqp_algebra = {auto, builtin, torch}
+```
+
+Do not expose nested low-level solver selectors until there are at least two
+validated implementations behind the same internal boundary.
+
+### 7. Public Contract
+
+Goal: define public behavior before changing solver internals.
+
+Inputs:
+
+* `H`: PyGRANSO QP Hessian-like matrix.
+* `f`: PyGRANSO QP linear vector.
+* `A`, `b`: inequality constraint matrix/vector.
+* `LB`, `UB`: variable lower/upper bounds.
+* `torch_device`: requested optimization device.
+* `double_precision`: selects float64 or float32 behavior.
+* `osqp_options`: contains `algebra`, common settings, and optional workspace.
+
+Outputs:
+
+* canonical OSQP problem `P`, `q`, `A_osqp`, `l`, `u`;
+* backend selection result;
+* solution/result tensor;
+* result on the requested or documented fallback device;
+* structured diagnostics when requested.
+
+Public settings:
+
+* accepted backend values: `auto`, `builtin`, `torch`;
+* accepted precisions: float32 and float64;
+* legacy CG/CUDA Graph settings: actionable migration error path;
+* unsupported explicit operations: clear failure rather than silent fallback.
+
+Validation:
+
+* Accepted `osqp_algebra` values are exactly `auto`, `builtin`, and `torch`.
+* CPU `auto` uses builtin OSQP.
+* Unsupported/unpromoted accelerator `auto` falls back with warning and telemetry.
+* Explicit `torch` never silently changes backend.
+* Unsupported options raise clear errors before low-level kernels.
+
+Exit Criteria:
+
+* Public behavior is stable.
+* Backend selection is deterministic and testable.
+* Fallback behavior is visible and recorded.
+* Invalid inputs fail before reaching low-level linear algebra.
+
+### 8. Canonical Problem Contract
+
+The canonical QP is:
+
+```text
+minimize    0.5 * x' P x + q' x
+subject to  l <= A x <= u
+```
+
+Requirements:
+
+* `P` is dense, finite, square, and symmetric within dtype-aware tolerance.
+* `q` is finite and compatible with `P`.
+* `A` is finite and has compatible row/column dimensions.
+* `l` and `u` may contain allowed infinities but never NaN.
+* `l <= u`.
+* All Torch tensors use the same device and dtype after normalization.
+* Only float32 and float64 are accepted.
+* Near-symmetric `P` may be symmetrized only within a tolerance proportional to
+  machine epsilon and `max(1, ||P||_inf)`.
+* Expensive eigenvalue/conditioning diagnostics are available for tests,
+  evidence, and debugging but are not always paid in normal solves.
+
+Validation Checklist:
+
+* Reject invalid shapes.
+* Reject NaN and unsupported Inf.
+* Reject unsupported dtype.
+* Normalize device and dtype consistently.
+* Preserve documented fallback behavior.
+* Add diagnostic checks for tests and evidence runners.
+
+### 9. Core Class / Registry Diagrams
+
+Use one ASCII diagram for every major class/module. The names below are the
+current project names; implementation plans may add helper names only when the
+source code actually introduces them.
+
+#### 9.1 Workspace Class
+
+```text
++-------------------------------------------------------------------------------+
+|                              TorchOSQPWorkspace                                |
++-------------------------------------------------------------------------------+
+|  - state: Dict[str, Tensor]                                                    |
+|  - problem_signature: Tuple | null                                             |
+|  - constraint_order_signature: Tuple | null                                    |
+|  - p_pattern: Tuple | null                                                     |
+|  - a_pattern: Tuple | null                                                     |
+|  - scaling: Dict[str, Tensor] | null                                           |
+|  - rho_bar: Tensor | null                                                      |
+|  - rho_setting: float | null                                                   |
+|  - active_backend: string | null                                               |
+|  - builtin_cache: Any | null                                                   |
+|  - builtin_stats: Dict[str, int]                                               |
+|  - linear_solver: DenseLUSolver                                                |
+|  - last_info: Dict[str, Any] | null                                            |
++-------------------------------------------------------------------------------+
+|  + ensure_backend(backend): bool        --> Switches backend and resets safely |
+|  + reset_torch(): void                  --> Clears Torch reusable state        |
+|  + reset_all(): void                    --> Clears all cached state            |
+|  + update_state(x, z, y): void          --> Saves warm-start state             |
+|  + set_scaling(...): void               --> Stores scaling metadata            |
+|  + set_diagnostics(info): void          --> Stores latest diagnostics          |
+|  + clear_factors(): void                --> Clears cached factorization        |
++-------------------------------------------------------------------------------+
+```
+
+Ownership rule: one BFGS-SQP run owns one private workspace. No module global may
+store warm state, solver factors, or backend cache.
+
+#### 9.2 Dense Linear Solver Class
+
+```text
++-------------------------------------------------------------------------------+
+|                                DenseLUSolver                                   |
++-------------------------------------------------------------------------------+
+|  - matrix: Tensor | null                                                       |
+|  - lu: Tensor | null                                                           |
+|  - pivots: Tensor | null                                                       |
+|  - factorization_status: Tensor | null                                         |
+|  - factorization_count: int                                                    |
+|  - solve_count: int                                                            |
++-------------------------------------------------------------------------------+
+|  + factorize(K): void                   --> Validates and factorizes matrix    |
+|  + solve(rhs): Tensor                   --> Solves using cached factors        |
+|  + factorize_if_needed(K): bool         --> Reuses or rebuilds factorization   |
+|  + clear(): void                        --> Clears matrix and factors          |
+|  + diagnostics(): LinearSolveDiagnostics --> Returns counters/status           |
++-------------------------------------------------------------------------------+
+```
+
+Validation rule: reject non-square matrices, nonfinite values, unsupported
+dtypes, failed factorization info, nonfinite factors, invalid RHS, and nonfinite
+solutions.
+
+#### 9.3 Linear Solve Diagnostics
+
+```text
++-------------------------------------------------------------------------------+
+|                           LinearSolveDiagnostics                               |
++-------------------------------------------------------------------------------+
+|  - solver_name: string                                                         |
+|  - factorization_info: int | string | null                                     |
+|  - factorization_count: int                                                    |
+|  - solve_count: int                                                            |
+|  - absolute_residual: float | null                                             |
+|  - relative_residual: float | null                                             |
++-------------------------------------------------------------------------------+
+|  + to_dict(): Dict[str, Any]            --> Serializes diagnostics             |
+|  + is_success(): bool                   --> Reports factor/solve success       |
++-------------------------------------------------------------------------------+
+```
+
+#### 9.4 Backend Selection / Adapter Module
+
+```text
++-------------------------------------------------------------------------------+
+|                         pygranso/private/osqpTorchAdapter.py                   |
++-------------------------------------------------------------------------------+
+|  - DEFAULT_OSQP_SETTINGS: Dict[str, Any]                                       |
+|  - PROMOTED_ACCELERATOR_BACKENDS: Dict[str, bool]                              |
+|  - MAX_SUPPORTED_KKT_DIM: int                                                  |
+|  - LINEAR_SOLVER_OPTION_KEYS: Set[str]                                         |
++-------------------------------------------------------------------------------+
+|  + solve_osqp_torch_qp(...): Result     --> Public adapter solve entry point   |
+|  + _select_backend(...): Dict           --> Applies auto/builtin/torch policy  |
+|  + estimate_dense_kkt(...): Tuple       --> Estimates KKT size and memory      |
+|  + _solve_builtin_osqp_path(...): Result--> Calls trusted builtin backend      |
+|  + _solve_torch_osqp_path(...): Result  --> Calls dense Torch implementation   |
+|  + _selection_fallback(...): Dict       --> Builds visible fallback metadata   |
++-------------------------------------------------------------------------------+
+```
+
+#### 9.5 Direct Algorithm Kernel
+
+```text
++-------------------------------------------------------------------------------+
+|                         pygranso/private/torchOSQP.py                          |
++-------------------------------------------------------------------------------+
+|  - No persistent global state                                                  |
++-------------------------------------------------------------------------------+
+|  + build_kkt_matrix(...): Tensor        --> Builds dense KKT matrix            |
+|  + build_kkt_rhs(...): Tensor           --> Builds solve right-hand side       |
+|  + recover_z_tilde(...): Tensor         --> Recovers intermediate constraint   |
+|  + admm_vector_update(...): Tuple       --> Performs ADMM vector update        |
+|  + solve_torch_osqp_direct(...): Dict   --> Main direct ADMM loop              |
++-------------------------------------------------------------------------------+
+```
+
+Rule: the kernel receives all reusable state through arguments or workspace. It
+does not own cross-run state.
+
+#### 9.6 Scaling / Numerical Feature Module
+
+```text
++-------------------------------------------------------------------------------+
+|                    torchOSQP scaling/adaptive/polishing helpers                |
++-------------------------------------------------------------------------------+
+|  - No persistent global state                                                  |
++-------------------------------------------------------------------------------+
+|  + _scaling_for_problem(...): Dict      --> Computes or reuses Ruiz scaling    |
+|  + _scale_problem(...): Tuple           --> Produces scaled QP tensors         |
+|  + _initial_scaled_state(...): Tuple    --> Creates compatible initial state   |
+|  + _unscale_state(...): Tuple           --> Converts result to original coords |
+|  + _adaptive_rho_update(...): Tuple     --> Applies deterministic rho update   |
+|  + _polish_solution(...): Dict          --> Runs optional dense polishing      |
+|  + _residuals(...): Tuple               --> Computes KKT acceptance metrics    |
++-------------------------------------------------------------------------------+
+```
+
+#### 9.7 Evidence / Stability Runner
+
+```text
++-------------------------------------------------------------------------------+
+|                               torch_osqp_stability.py                          |
++-------------------------------------------------------------------------------+
+|  - seed_list: List[int]                                                        |
+|  - stress_seed_list: List[int]                                                 |
+|  - backend/device/dtype matrix                                                 |
+|  - output_dir: Path                                                            |
+|  - time_limit_seconds: float                                                   |
++-------------------------------------------------------------------------------+
+|  + run_case(...): Dict                  --> Runs one deterministic case        |
+|  + write_results_csv(...): Path         --> Writes case-level results          |
+|  + write_manifest(...): Path            --> Writes provenance/settings data    |
+|  + write_summary(...): Path             --> Writes human-readable summary      |
+|  + save_failure_case(...): Path         --> Saves reproduction artifact        |
++-------------------------------------------------------------------------------+
+```
+
+### 10. Workspace Lifecycle Contract
+
+| Operation | Input Change | Preserved Output | Invalidated Output |
+| --- | --- | --- | --- |
+| Vector-only update | Same `P`/`A` values and structure, new `q`/`l`/`u` | `x`, `z`, `y`, rho, scaling, LU | none |
+| Matrix-value update | Same shape/pattern/dtype/device/order, changed `P` or `A` values | `x`, `z`, `y` | scaling and LU |
+| Parameter change | Compatible problem, changed rho or sigma | `x`, `z`, `y` | LU |
+| Structure change | Changed shape, pattern, or constraint ordering | none | warm state, scaling, LU |
+| Dtype/device/backend change | Changed dtype, device, or selected backend | none | complete workspace |
+
+Workspace validation:
+
+* Unit-test vector-only update reuse.
+* Unit-test matrix-value update refactorization.
+* Unit-test parameter-change refactorization.
+* Unit-test structure-change invalidation.
+* Unit-test dtype/device/backend complete reset.
+* Confirm diagnostics explain reuse, rebuild, and reset.
+
+Exit Criteria:
+
+* No global warm state exists.
+* Every reusable object has one owner.
+* Every invalidation path is deterministic.
+* Reuse is visible through diagnostics.
+
+### 11. Dense Linear-Solver Lifecycle
+
+```text
+factorize(K)
+  validate square shape, dtype, device, and finite values
+  call torch.linalg.lu_factor_ex(K, check_errors=False)
+  reject failed factorization info
+  reject nonfinite factors
+  cache matrix clone, factors, pivots/status
+  increment factorization_count
+
+solve(rhs)
+  normalize vector RHS to shape (n, 1)
+  validate shape, dtype, device, and finite values
+  call torch.linalg.lu_solve(LU, pivots, rhs)
+  reject nonfinite solution
+  optionally report ||Kx-b|| / max(1, ||b||)
+  increment solve_count
+
+factorize_if_needed(K)
+  compare K to cached matrix using documented compatibility rule
+  reuse if compatible
+  refactorize if incompatible
+```
+
+Validation:
+
+* Reject non-square matrix.
+* Reject nonfinite matrix.
+* Reject unsupported dtype.
+* Reject RHS with wrong shape.
+* Support vector RHS and matrix RHS.
+* Restore vector output shape when appropriate.
+* Detect failed factorization.
+* Detect nonfinite solution.
+* Report factorization and solve counters.
+
+### 12. Algorithm Equations / Core Math
+
+The direct KKT system is:
+
+```text
+[ P + sigma I    A'          ] [x_tilde] = [sigma x - q]
+[ A             -diag(rho)^-1] [nu     ]   [z - y/rho ]
+```
+
+Recover and update:
+
+```text
+z_tilde = z + (nu - y) / rho
+x_next = alpha * x_tilde + (1-alpha) * x
+z_relaxed = alpha * z_tilde + (1-alpha) * z
+z_next = project_box(z_relaxed + y/rho, l, u)
+y_next = y + rho * (z_relaxed - z_next)
+```
+
+Acceptance metrics are evaluated in original coordinates:
+
+```text
+r_primal = ||A x - z||_inf
+r_dual   = ||P x + q + A' y||_inf
+objective = 0.5 * x' P x + q' x
+```
+
+Rules:
+
+* Preserve the OSQP ADMM equations.
+* Do not change equations to make tests pass.
+* Evaluate final residuals/metrics in original coordinates.
+* Accept nonunique solutions by observable metrics, not exact vector equality.
+* Raise or report numerical failure as numerical failure, not infeasibility.
+
+### 13. Required Numerical Features
+
+#### 13.1 Scaling
+
+Use ten deterministic Ruiz diagonal-equilibration passes.
+
+Rules:
+
+* Compute scaling deterministically.
+* Cache scaling for compatible vector-only updates.
+* Solve the scaled problem if enabled.
+* Unscale `x`, `z`, and `y` before reporting.
+* Report acceptance metrics in original coordinates.
+
+#### 13.2 Adaptive Parameter Update
+
+Use deterministic adaptive rho with interval `50` and tolerance `5`.
+
+Rules:
+
+* Update rho deterministically.
+* Apply the larger vector-valued rho policy for equality rows.
+* Rebuild factorization after an accepted rho change.
+* Continue from current `x`, `z`, and `y`.
+* Record rho changes in diagnostics.
+
+#### 13.3 Polishing / Refinement
+
+Use dense active-set polishing through the same LU boundary.
+
+Rules:
+
+* Build polishing systems through `DenseLUSolver`.
+* Reuse factorization when valid.
+* Accept a candidate only when its KKT metric is nonworse or satisfies tolerance.
+* Raise requested polishing failure when polishing was requested and cannot be accepted.
+* Never silently degrade an accepted result.
+
+#### 13.4 Warm Starts
+
+Rules:
+
+* Enable warm starts internally.
+* Reuse warm state for compatible updates.
+* Recompute scaling and factors when matrix values change.
+* Clear workspace on structural, dtype, device, or backend changes.
+* Make warm-start reuse observable through diagnostics.
+
+### 14. Defaults
+
+| Setting | Default |
+| --- | --- |
+| `rho` | `0.1` |
+| `sigma` | `1e-6` |
+| `alpha` | `1.6` |
+| `max_iter` | `4000` |
+| `check_termination` | `25` |
+| float64 `eps_abs` | `1e-8` |
+| float64 `eps_rel` | `1e-8` |
+| float32 `eps_abs` | `1e-5` |
+| float32 `eps_rel` | `1e-5` |
+| scaling | `10` Ruiz passes |
+| adaptive rho | `true` |
+| rho update interval | `50` |
+| rho update tolerance | `5` |
+| polishing | `true` |
+| warm start | `true` |
+
+### 15. Backend Selection and Fallback
+
+| Request | Behavior |
+| --- | --- |
+| `auto` on CPU | Use builtin OSQP |
+| `auto` on validated accelerator inside limits | Use Torch backend |
+| `auto` on unsupported/unpromoted accelerator | Warn and use builtin OSQP |
+| `auto` above size or memory envelope | Warn and use builtin OSQP |
+| `auto` Torch exception | Warn, retry builtin OSQP, retain causal telemetry |
+| `auto` Torch unsolved status | Warn, retry builtin OSQP, retain causal telemetry |
+| explicit `builtin` | Use builtin OSQP |
+| explicit `torch` inside limits | Use Torch backend |
+| explicit `torch` above limits | Warn and attempt; never silently change backend |
+
+Fallback diagnostics must include:
+
+* requested backend;
+* selected backend;
+* fallback backend;
+* trigger;
+* original exception or status;
+* fallback status;
+* device-transfer flag;
+* result device;
+* reproducibility notes.
+
+### 16. Status and Error Semantics
+
+Return structured statuses for:
+
+* solved;
+* maximum iterations;
+* fallback success;
+* fallback failure;
+* unsupported auto route;
+* stress-only classification.
+
+Raise for:
+
+* invalid inputs;
+* unsupported explicit operations;
+* failed factorization;
+* NaN or Inf where forbidden;
+* numerical polishing failure when polishing is requested;
+* impossible workspace state;
+* failed explicit backend request.
+
+Do not claim yet:
+
+* primal infeasibility certificate;
+* dual infeasibility certificate;
+* nonconvex detection;
+* sparse large-scale performance;
+* unsupported accelerator support.
+
+Move these to future work unless implementation and tests exist.
+
+### 17. Validation Pipeline
+
+```text
+Low-level solver tests
+  -> KKT assembly and equation tests
+  -> deterministic complete-problem tests
+  -> scaling/adaptive-rho/polishing/warm-state tests
+  -> builtin-vs-Torch differential tests
+  -> PyGRANSO integration contracts
+  -> metamorphic tests
+  -> seeded randomized and conditioning tests
+  -> end-to-end workloads
+  -> backend-specific hardware gates
+  -> performance sanity gate
+```
+
+Core validation:
+
+* Linear solver tests.
+* KKT/system matrix assembly tests.
+* RHS construction tests.
+* ADMM vector update equation tests.
+* Projection/constraint handling tests.
+* Finite solution tests.
+* Residual and objective tests.
+
+Differential validation:
+
+* Compare builtin OSQP and Torch using identical settings.
+* Compare status compatibility.
+* Compare residuals.
+* Compare objective gap.
+* Compare feasibility and stationarity.
+* Do not require exact iterate, trajectory, or iteration-count match.
+
+Metamorphic validation:
+
+* Scaling transformation preserves original-coordinate solution quality.
+* Equivalent constraint/order cases preserve metrics or invalidate correctly.
+* Vector-only updates reuse factors when allowed.
+* Matrix changes refactorize when required.
+* Dtype/device/backend changes reset state.
+
+Randomized validation:
+
+* Fixed seeds.
+* Multiple size buckets.
+* Multiple conditioning buckets.
+* Multiple dtype buckets.
+* Failure reproduction artifacts saved.
+* Stress cases separated from supported claims.
+
+End-to-end validation:
+
+* Run PyGRANSO workloads.
+* Validate steering, stationarity, penalty, and fallback contracts.
+* Confirm fallback does not break caller contract.
+* Confirm result device behavior.
+* Confirm structured info is stable.
+
+### 18. Evidence Package
+
+Each stability or release-validation run must produce:
+
+* `torch_osqp_stability_results.csv` with case-level gates;
+* `torch_osqp_stability_manifest.json` with commit, platform, hardware, Python,
+  PyTorch, OSQP, backend, settings, and seeds;
+* `torch_osqp_stability_summary.md` with family totals and pass/fail classification;
+* serialized reproduction file for every failure;
+* CI artifacts for core, nightly, and hardware workflows when those workflows run.
+
+Manifest requirements:
+
+* commit hash;
+* dirty-worktree state before generated artifacts;
+* platform;
+* hardware;
+* Python version;
+* PyTorch version;
+* OSQP/library versions;
+* backend;
+* dtype;
+* settings;
+* seeds;
+* time budget;
+* `timed_out` flag;
+* `partial_results` flag;
+* last completed case;
+* source hash over maintained code/tests/workflows/docs.
+
+Timeout rule:
+
+If the time budget is exceeded after a case completes:
+
+* write all collected artifacts;
+* mark `timed_out=true`;
+* mark `partial_results=true`;
+* record the last completed case;
+* exit nonzero;
+* classify the run as reproducible telemetry, not passing release evidence.
+
+### 19. Performance Gate
+
+Performance is not a correctness criterion. Performance controls only automatic
+backend promotion.
+
+Promotion rule:
+
+```text
+On representative workloads, Torch accelerator median end-to-end time must be
+no worse than 5x builtin CPU OSQP.
+```
+
+If a backend passes correctness but fails performance:
+
+* it remains explicit-only or unclaimed;
+* `auto` falls back visibly;
+* correctness evidence remains useful regression evidence.
+
+Performance checklist:
+
+* Benchmark includes setup and transfer cost.
+* Benchmark uses representative workloads.
+* Median runtime is reported.
+* Slowdown ratio is reported.
+* Backend promotion decision is recorded.
+* Failing performance gate does not invalidate correctness evidence.
+
+### 20. Milestone Roadmap
+
+Each phase is complete only when:
+
+* interface is implemented;
+* data structures are implemented;
+* tests are implemented;
+* evidence artifacts are produced when required;
+* exit criteria are satisfied;
+* roadmap checkbox is updated only for verified work.
+
+This repository keeps backend promotion in Phase 4.3 and documentation handoff
+in Phase 5.1 to match existing plan files.
+
+#### Phase 0 - Research Snapshot and Rollback Point
+
+Goal: preserve prior experimental sparse-CG/CUDA Graph work before narrowing the
+active package path.
+
+Plan files:
+
+* [Phase 0.1 archive snapshot](phase_0.1_archive_snapshot_plan.md)
+* [Phase 0.2 remove research paths](phase_0.2_remove_research_paths_plan.md)
+
+Tasks:
+
+- [x] Create archive branch `archive/sparse-cg-cuda-graph`.
+- [x] Create signed tag `research-sparse-cg-cuda-graph-final`.
+- [x] Push archive branch and tag.
+- [x] Record baseline validation result.
+- [x] Remove unsupported research execution paths from active package code.
+- [x] Verify active package no longer imports removed paths.
+
+Exit Criteria:
+
+* Reviewer can recover research snapshot from git.
+* Active route contains no hidden unsupported sparse-CG/CUDA Graph execution path.
+
+#### Phase 1 - Public Contract and Backend Policy
+
+Goal: define public behavior before implementing/expanding dense backend internals.
+
+Plan files:
+
+* [Phase 1.1 public QP contract](phase_1.1_public_qp_contract_plan.md)
+* [Phase 1.2 backend policy and fallback telemetry](phase_1.2_backend_policy_and_fallback_plan.md)
+* [Phase 1.3 settings validation and migration](phase_1.3_settings_validation_and_migration_plan.md)
+
+Tasks:
+
+- [x] Define canonical input contract.
+- [x] Define accepted backend options.
+- [x] Define common default settings.
+- [x] Implement backend selection.
+- [x] Implement fallback telemetry shape.
+- [x] Implement canonical problem builder.
+- [x] Add unsupported-option migration errors.
+- [x] Add public contract tests.
+
+Exit Criteria:
+
+* Public behavior is stable.
+* Inner solver can evolve behind the adapter without changing API.
+
+#### Phase 2.1 - Data Model, Workspace, and Factorization Lifecycle
+
+Goal: make reusable state explicit, private, and safe across repeated solves.
+
+Plan file:
+
+* [Phase 2.1 dense LU workspace lifecycle](phase_2.1_dense_lu_workspace_plan.md)
+
+Tasks:
+
+- [x] Implement `TorchOSQPWorkspace`.
+- [x] Implement `DenseLUSolver`.
+- [x] Implement `LinearSolveDiagnostics`.
+- [x] Implement workspace backend switching.
+- [x] Implement factorization reuse.
+- [x] Implement deterministic invalidation rules.
+- [x] Add tests for vector-only updates.
+- [x] Add tests for matrix-value updates.
+- [x] Add tests for parameter updates.
+- [x] Add tests for structure/dtype/device/backend changes.
+
+Exit Criteria:
+
+* No module global stores reusable state.
+* Every reusable object has one owner.
+* Diagnostics explain reused, rebuilt, and cleared factors.
+
+#### Phase 2.2 - Dense Direct Algorithm Kernel
+
+Goal: implement the dense reference ADMM algorithm around the factorization boundary.
+
+Plan file:
+
+* [Phase 2.2 direct ADMM kernel](phase_2.2_direct_admm_kernel_plan.md)
+
+Tasks:
+
+- [x] Build KKT/system matrix.
+- [x] Build RHS.
+- [x] Implement vector updates.
+- [x] Implement projection/constraint update.
+- [x] Implement residual computation.
+- [x] Implement objective computation.
+- [x] Implement solved/max-iteration status handling.
+- [x] Update workspace state after solve.
+- [x] Record factorization and iteration counters.
+
+Exit Criteria:
+
+* Algorithm equations match specification.
+* Numerical failures are raised or reported as unsolved.
+* Numerical failures are not mislabeled as infeasibility.
+
+#### Phase 2.3 - Scaling, Adaptive Updates, Polishing, and Warm Starts
+
+Goal: add numerical features required for observable agreement with builtin OSQP.
+
+Plan file:
+
+* [Phase 2.3 scaling, adaptive rho, polishing, and warm starts](phase_2.3_scaling_adaptive_polishing_plan.md)
+
+Tasks:
+
+- [x] Implement deterministic Ruiz scaling.
+- [x] Implement problem scaling.
+- [x] Implement state initialization.
+- [x] Implement state unscaling.
+- [x] Implement adaptive rho update.
+- [x] Implement polishing/refinement.
+- [x] Implement original-coordinate residuals.
+- [x] Implement warm-start reuse.
+- [x] Implement warm-start invalidation.
+
+Exit Criteria:
+
+* Acceptance metrics are reported in original coordinates.
+* Polishing cannot silently degrade a valid result.
+* Compatible warm starts are observable through diagnostics.
+
+#### Phase 3 - Builtin Parity, Fallback, and PyGRANSO Integration
+
+Goal: make builtin OSQP and dense Torch comparable through one adapter contract,
+then verify the contract inside PyGRANSO.
+
+Plan files:
+
+* [Phase 3.1 builtin OSQP parity](phase_3.1_builtin_parity_plan.md)
+* [Phase 3.2 PyGRANSO integration](phase_3.2_pygranso_integration_plan.md)
+
+Tasks:
+
+- [x] Implement builtin/reference backend path.
+- [x] Implement shared metric computation.
+- [x] Implement builtin cache/update behavior where compatible.
+- [x] Implement fallback trigger handling.
+- [x] Implement fallback telemetry.
+- [x] Implement result device policy.
+- [x] Implement memory and size preflight.
+- [x] Add parity tests.
+- [x] Add PyGRANSO steering/stationarity/fallback tests.
+
+Exit Criteria:
+
+* Automatic fallback is always visible.
+* Explicit failures remain explicit.
+* Backend comparison uses shared metrics.
+* PyGRANSO's outer fallback contract remains intact.
+
+#### Phase 4 - Validation Evidence and Backend Promotion
+
+Goal: prove behavior through deterministic, differential, metamorphic,
+randomized, end-to-end, and platform gates; promote backends only after evidence.
+
+Plan files:
+
+* [Phase 4.1 tests and differential validation](phase_4.1_tests_and_differential_plan.md)
+* [Phase 4.2 stability evidence package](phase_4.2_stability_evidence_plan.md)
+* [Phase 4.3 platform gates and backend promotion](phase_4.3_platform_promotion_plan.md)
+
+Tasks:
+
+- [x] Add deterministic unit test suite.
+- [x] Add differential backend tests.
+- [x] Add metamorphic tests.
+- [x] Add randomized stability runner.
+- [x] Add conditioning tests.
+- [x] Add end-to-end workload/performance tests.
+- [x] Add evidence CSV output.
+- [x] Add evidence manifest output.
+- [x] Add Markdown summary output.
+- [x] Add failure reproduction output.
+- [x] Add core CI workflow.
+- [x] Add nightly workflow file on the feature branch.
+- [x] Register and run nightly workflow on fork `main`.
+- [x] Add hardware promotion workflow file on the feature branch.
+- [ ] Register/merge nightly and hardware workflows on upstream `main` before relying on upstream schedules/dispatch.
+- [ ] Promote CUDA only after representative correctness and <=5x performance evidence.
+- [ ] Obtain ROCm and MPS runners before making either support claim.
+
+Exit Criteria:
+
+* Zero unexplained failures inside the supported matrix.
+* Stress rows are classified as stress evidence, not support claims.
+* Evidence package is reproducible.
+* No backend is promoted by assumption.
+
+#### Phase 5.1 - Documentation, PDF, and Release Handoff
+
+Goal: make the implementation reviewable and reproducible.
+
+Plan file:
+
+* [Phase 5.1 documentation, PDF, and release handoff](phase_5.1_documentation_pdf_release_plan.md)
+
+Tasks:
+
+- [x] Maintain Markdown specification.
+- [x] Render PDF.
+- [x] Add completion audit.
+- [x] Add code-edit log entries.
+- [x] Verify docs match current source and evidence.
+- [x] Verify evidence artifact expectations.
+- [x] Verify roadmap checkboxes for already-implemented work.
+- [x] Open or update release PR from `feature/torch-osqp-dense-reference`.
+- [x] Verify fork `main` workflow registration and nightly CPU evidence.
+
+Exit Criteria:
+
+* Reviewer can follow public API, data model, solver lifecycle, validation, and
+  release evidence without reading implementation code first.
+
+#### Phase 5.2 - Fork-Local Release Candidate Hardening
+
+Goal: treat the fork, not the original repo PR, as the active validation target, and review local/fork evidence.
+
+Plan file:
+
+* [phase_5.2_fork_local_hardening_plan.md](phase_5.2_fork_local_hardening_plan.md)
+
+Tasks:
+
+- [x] Run `git status --short --branch` to check local cleanliness.
+- [x] Confirm latest fork `main` core and nightly workflows pass.
+- [x] Aggregate and verify latest fork-main nightly artifacts (1800 CPU cases, 0 failures).
+- [x] Run local deterministic tests with temp-directory bypass where necessary.
+- [x] Document final release-candidate readiness status in external Report notebook.
+- [x] Do not merge or trigger upstream pull request actions.
+
+Exit Criteria:
+
+* Fork-local release readiness is defined, verified, and documented.
+* Core and nightly GHA workflows pass on the fork.
+* No accelerator support is overclaimed.
+
+### 21. Migration Sequence
+
+1. [x] Preserve prior sparse-CG/CUDA Graph research snapshot.
+2. [x] Create and push archive branch `archive/sparse-cg-cuda-graph`.
+3. [x] Create and push signed tag `research-sparse-cg-cuda-graph-final`.
+4. [x] Remove custom CG, Jacobi, sparse-operator, CUDA Graph, and selection code from the package path.
+5. [x] Add workspace and linear-solver tests.
+6. [x] Implement reusable factorization boundary.
+7. [x] Refactor direct algorithm around that boundary.
+8. [x] Add scaling, adaptive rho, polishing, and warm starts.
+9. [x] Implement backend policy, migration errors, size guards, and fallback telemetry.
+10. [x] Add differential, randomized, hardware-workflow, end-to-end, and reporting gates.
+11. [ ] Promote each accelerator backend only after its correctness and performance evidence passes.
+12. [x] Update release PR and verify fork default-branch workflow registration.
+13. [ ] Obtain upstream review/merge and upstream default-branch workflow registration.
+14. [x] After completed roadmap tasks, change only verified checkboxes from `[ ]` to `[x]`.
+
+### 22. Decision Log
+
+| Decision | Rationale |
+| --- | --- |
+| Dense reference route first | Correctness and maintainability are primary |
+| Torch-native implementation | PyGRANSO already uses Torch tensors and device-aware optimization |
+| Reusable factorization | Avoid repeated expensive setup inside ADMM and compatible updates |
+| Observable agreement | Different devices/backends need not match trajectories |
+| Float64 authoritative | Float32 degrades materially on ill-conditioned KKT systems |
+| Float32 qualified separately | Audit evidence only supports looser/condition-limited float32 claims |
+| Feasible convex QP scope first | Avoid unvalidated certificate and nonconvex claims |
+| `auto` follows device only after gates | Avoid unsupported or unprofitable accelerator selection |
+| Per-run workspace | Prevent cross-run state contamination |
+| Backend-by-backend promotion | Support claims require real hardware and evidence |
+| Five-times performance ceiling | Prevent severe automatic regressions without making speed a correctness criterion |
+| Keep ROCm/MPS unclaimed | No real runner evidence exists yet |
+| PR deferred until project perfect | PR #63 and workflow registration are deferred to prevent merging before all aspects of the solver and platform verification are perfect |
+| Use built-in PyTorch routines | Avoid designing custom linear solvers; rely entirely on GPU-boosted built-in PyTorch linear algebra (e.g., lu_factor_ex/lu_solve) for correctness and standard acceleration |
+
+### 23. Future Work
+
+After the dense reference route passes applicable gates and release review, future
+backends may implement the same internal interface.
+
+Potential future backend candidates:
+
+* sparse direct backend;
+* iterative backend;
+* GPU direct solver;
+* batched solver;
+* vendor-specific solver such as cuDSS;
+* future PyTorch sparse solver;
+* future Torch sparse linear algebra route.
+
+Rules for future work:
+
+* Do not change public API unnecessarily.
+* Do not change evidence schema unnecessarily.
+* Keep the same factorize/solve/refactorize contract.
+* Keep existing tests.
+* Add backend-specific evidence before promotion.
+* Do not claim unsupported certificates or nonconvex detection until implemented and validated.
diff --git a/pygranso/private/bfgsHessianInverse.py b/pygranso/private/bfgsHessianInverse.py
index a0fcceb..96e4b87 100644
--- a/pygranso/private/bfgsHessianInverse.py
+++ b/pygranso/private/bfgsHessianInverse.py
@@ -185,8 +185,8 @@ def update(self, s, y, sty, damped=False):
             + sscaled @ torch.conj(sscaled.t())
         )
         H_vec = torch.reshape(H_new, (torch.numel(H_new), 1))
-        notInf_flag = torch.all(not torch.isinf(H_vec))
-        notNan_flag = torch.all(not torch.isnan(H_vec))
+        notInf_flag = torch.all(torch.logical_not(torch.isinf(H_vec)))
+        notNan_flag = torch.all(torch.logical_not(torch.isnan(H_vec)))
 
         if notInf_flag and notNan_flag:
             self.H = H_new
diff --git a/pygranso/private/bfgssqp.py b/pygranso/private/bfgssqp.py
index 9bf0b9e..d5951d9 100644
--- a/pygranso/private/bfgssqp.py
+++ b/pygranso/private/bfgssqp.py
@@ -10,6 +10,7 @@
 from pygranso.private import pygransoConstants as pC
 from pygranso.private import regularizePosDefMatrix as rPDM
 from pygranso.private.neighborhoodCache import nC
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
 from pygranso.private.qpSteeringStrategy import qpSS
 from pygranso.private.qpTerminationCondition import qpTC
 from pygranso.pygransoStruct import pygransoStruct
@@ -179,6 +180,12 @@ def bfgssqp(self, penaltyfn_obj, bfgs_obj, opts, printer, torch_device):
         self.regularize_max_eigenvalues = opts.regularize_max_eigenvalues
 
         self.QPsolver = opts.QPsolver
+        self.osqp_workspace = TorchOSQPWorkspace()
+        self.osqp_options = {
+            "algebra": opts.osqp_algebra,
+            "settings": opts.osqp_settings,
+            "workspace": self.osqp_workspace,
+        }
 
         # experimental options
         self.stat_l2_model = opts.stat_l2_model
@@ -318,6 +325,7 @@ def steering_fn(penaltyfn_parts, H):
                 self.QPsolver,
                 torch_device,
                 self.double_precision,
+                self.osqp_options,
             )
 
         self.linesearch_fn = lambda x, f, g, p, ls_maxit: lWW.linesearchWeakWolfe(
@@ -684,11 +692,16 @@ def computeApproxStationarityVector(self):
                 self.QPsolver,
                 self.torch_device,
                 self.double_precision,
+                self.osqp_options,
             )
-        except Exception:
+        except Exception as exc:
             print("PyGRANSO:terminationQuadprogFailure")
             print(traceback.format_exc())
-            [stat_vec, n_qps, ME] = [None, 1, None]  # set a very large stat vec
+            stat_vec = torch.full_like(
+                self.penaltyfn_at_x.f_grad,
+                float("inf"),
+            )
+            [n_qps, ME] = [0, [exc]]
 
         if self.stat_l2_model:
             stat_value = torch.linalg.vector_norm(stat_vec, ord=2).item()
diff --git a/pygranso/private/osqpTorchAdapter.py b/pygranso/private/osqpTorchAdapter.py
new file mode 100644
index 0000000..603a2c4
--- /dev/null
+++ b/pygranso/private/osqpTorchAdapter.py
@@ -0,0 +1,930 @@
+"""Backend policy and canonicalization for PyGRANSO OSQP subproblems."""
+
+from __future__ import annotations
+
+import importlib
+import warnings
+from numbers import Integral, Number
+
+import numpy as np
+import torch
+from scipy import sparse
+
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+from pygranso.private.torchOSQP import _polish_solution, solve_torch_osqp_direct
+
+MAX_SUPPORTED_KKT_DIM = 2400
+MAX_AUTO_ESTIMATED_MEMORY_MB = 512.0
+PROMOTED_ACCELERATOR_BACKENDS = {
+    "cuda": False,
+    "rocm": False,
+    "mps": False,
+}
+LEGACY_TORCH_SETTINGS = {
+    "linear_solver",
+    "cg_rtol",
+    "cg_atol",
+    "cg_max_iter",
+    "cg_check_interval",
+    "cg_fixed_iters",
+    "torch_compile_admm",
+    "cuda_graph",
+    "cuda_event_timing",
+    "linear_solver_auto_min_kkt_dim",
+    "linear_solver_auto_sparse_min_kkt_dim",
+    "linear_solver_auto_max_density",
+    "linear_solver_auto_dense_memory_limit_mb",
+}
+
+DEFAULT_OSQP_SETTINGS = {
+    "rho": 0.1,
+    "sigma": 1e-6,
+    "alpha": 1.6,
+    "max_iter": 4000,
+    "eps_abs": 1e-8,
+    "eps_rel": 1e-8,
+    "check_termination": 25,
+    "scaling": 10,
+    "adaptive_rho": True,
+    "rho_update_interval": 50,
+    "rho_update_tolerance": 5.0,
+    "warm_start": True,
+    "polishing": True,
+    "polish_delta": 1e-6,
+    "polish_refine_iter": 3,
+    "check_linear_residual": False,
+    "check_convexity": False,
+    "check_condition": False,
+    "symmetry_tolerance_multiplier": 100.0,
+    "return_state": False,
+    "return_info": False,
+    "verbose": False,
+}
+DEFAULT_TORCH_OSQP_SETTINGS = dict(DEFAULT_OSQP_SETTINGS)
+
+
+def solve_osqp_torch_qp(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    torch_device,
+    double_precision,
+    options=None,
+    workspace: TorchOSQPWorkspace | None = None,
+):
+    """Solve PyGRANSO's QP form and return a Torch column vector."""
+
+    workspace = workspace or TorchOSQPWorkspace()
+    target_device = _canonical_device(torch_device)
+    torch_dtype = torch.float64 if double_precision else torch.float32
+    _validate_torch_input_compatibility(
+        H, f, A, b, LB, UB, expected_dtype=torch_dtype
+    )
+    opts = _normalize_options(options, torch_dtype)
+    settings = opts["settings"]
+    selection = _select_backend(
+        opts["algebra"],
+        target_device,
+        torch_dtype,
+        H,
+        f,
+        A,
+        b,
+    )
+
+    if selection["backend"] == "builtin":
+        backend_changed = workspace.ensure_backend("builtin")
+        result_device = _builtin_result_device(
+            target_device,
+            torch_dtype,
+            selection["selection_reason"],
+        )
+        solution, info = _solve_builtin_osqp_path(
+            H,
+            f,
+            A,
+            b,
+            LB,
+            UB,
+            result_device,
+            target_device,
+            torch_dtype,
+            settings,
+            workspace,
+        )
+        selection["workspace_invalidated_for_backend_change"] = backend_changed
+        info.update(selection)
+        workspace.last_info = dict(info)
+        return (solution, info) if settings["return_info"] else solution
+
+    torch_failure = None
+    backend_changed = workspace.ensure_backend("torch")
+    try:
+        solution, torch_info = _solve_torch_osqp_path(
+            H,
+            f,
+            A,
+            b,
+            LB,
+            UB,
+            target_device,
+            torch_dtype,
+            settings,
+            workspace,
+            allow_device_move=opts["algebra"] == "auto",
+        )
+        selection["workspace_invalidated_for_backend_change"] = backend_changed
+        torch_info.update(selection)
+        if torch_info.get("status_compatible", False):
+            workspace.last_info = dict(torch_info)
+            return (solution, torch_info) if settings["return_info"] else solution
+        torch_failure = {
+            "trigger": "unsolved_status",
+            "status": torch_info.get("status"),
+            "message": "Torch OSQP did not return a solved-compatible status.",
+            "torch_info": torch_info,
+        }
+    except Exception as exc:
+        if opts["algebra"] != "auto":
+            raise
+        torch_failure = {
+            "trigger": "exception",
+            "exception_type": type(exc).__name__,
+            "message": str(exc),
+        }
+
+    if opts["algebra"] != "auto":
+        workspace.last_info = dict(torch_info)
+        raise RuntimeError(
+            "Explicit Torch OSQP did not produce a solved-compatible result: "
+            f"{torch_info.get('status', 'unknown')}."
+        )
+
+    warnings.warn(
+        "Automatic Torch OSQP did not produce a solved-compatible result; "
+        f"falling back to builtin CPU OSQP ({torch_failure['message']}).",
+        RuntimeWarning,
+        stacklevel=2,
+    )
+    backend_changed = workspace.ensure_backend("builtin")
+    solution, builtin_info = _solve_builtin_osqp_path(
+        H,
+        f,
+        A,
+        b,
+        LB,
+        UB,
+        _builtin_result_device(
+            target_device,
+            torch_dtype,
+            "torch_failed_or_unsolved",
+        ),
+        target_device,
+        torch_dtype,
+        settings,
+        workspace,
+    )
+    builtin_info["fallback"] = {
+        "occurred": True,
+        "requested_backend": "auto",
+        "selected_backend": "torch",
+        "fallback_backend": "builtin",
+        "device_transfer": target_device.type != "cpu",
+        "workspace_invalidated_for_backend_change": backend_changed,
+        **torch_failure,
+    }
+    builtin_info.update(
+        {
+            "backend": "builtin",
+            "selection_reason": "torch_failed_or_unsolved",
+        }
+    )
+    workspace.last_info = dict(builtin_info)
+    return (solution, builtin_info) if settings["return_info"] else solution
+
+
+def _select_backend(algebra, target_device, dtype, H, f, A, b):
+    kkt_dim, memory_mb = estimate_dense_kkt(H, f, A, b, dtype)
+    metadata = {
+        "requested_backend": algebra,
+        "estimated_kkt_dim": kkt_dim,
+        "estimated_dense_working_memory_mb": memory_mb,
+    }
+    if algebra == "builtin":
+        return {
+            **metadata,
+            "backend": "builtin",
+            "selection_reason": "explicit",
+            "fallback": {"occurred": False},
+        }
+    if algebra == "torch":
+        if kkt_dim > MAX_SUPPORTED_KKT_DIM or memory_mb > _memory_limit_mb(target_device):
+            warnings.warn(
+                "Explicit Torch OSQP exceeds the validated dense envelope "
+                f"(KKT dimension {kkt_dim}, estimated {memory_mb:.1f} MiB); "
+                "attempting the solve as requested.",
+                RuntimeWarning,
+                stacklevel=3,
+            )
+        return {
+            **metadata,
+            "backend": "torch",
+            "selection_reason": "explicit",
+            "fallback": {"occurred": False},
+        }
+
+    if target_device.type == "cpu":
+        return {
+            **metadata,
+            "backend": "builtin",
+            "selection_reason": "cpu_target_uses_builtin",
+            "fallback": {"occurred": False},
+        }
+    supported, reason = _accelerator_capability(target_device, dtype)
+    if not supported:
+        warnings.warn(
+            f"Torch OSQP is not validated for {target_device}/{dtype}: {reason}. "
+            "Falling back to builtin CPU OSQP.",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        return _selection_fallback(metadata, reason, target_device)
+    if kkt_dim > MAX_SUPPORTED_KKT_DIM:
+        warnings.warn(
+            f"Automatic Torch OSQP KKT dimension {kkt_dim} exceeds the "
+            f"validated limit {MAX_SUPPORTED_KKT_DIM}; using builtin OSQP.",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        return _selection_fallback(metadata, "kkt_dimension_limit", target_device)
+    if memory_mb > _memory_limit_mb(target_device):
+        warnings.warn(
+            f"Automatic Torch OSQP estimated memory {memory_mb:.1f} MiB "
+            "exceeds the conservative preflight; using builtin OSQP.",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        return _selection_fallback(metadata, "memory_preflight", target_device)
+    return {
+        **metadata,
+        "backend": "torch",
+        "selection_reason": "validated_accelerator_target",
+        "fallback": {"occurred": False},
+    }
+
+
+def _selection_fallback(metadata, reason, target_device):
+    return {
+        **metadata,
+        "backend": "builtin",
+        "selection_reason": reason,
+        "fallback": {
+            "occurred": True,
+            "trigger": "selection_policy",
+            "requested_backend": "auto",
+            "selected_backend": "builtin",
+            "fallback_backend": "builtin",
+            "reason": reason,
+            "device_transfer": target_device.type != "cpu",
+        },
+    }
+
+
+def estimate_dense_kkt(H, f, A, b, dtype):
+    n = int(_shape_length(f))
+    n_eq = 0
+    if A is not None and b is not None:
+        shape = tuple(A.shape) if hasattr(A, "shape") else np.asarray(A).shape
+        n_eq = 1 if len(shape) == 1 else int(shape[0])
+    kkt_dim = 2 * n + n_eq
+    dtype_bytes = torch.empty((), dtype=dtype).element_size()
+    memory_mb = 3.0 * kkt_dim * kkt_dim * dtype_bytes / (1024 * 1024)
+    return int(kkt_dim), float(memory_mb)
+
+
+def _shape_length(value):
+    if torch.is_tensor(value):
+        return value.numel()
+    return np.asarray(value).size
+
+
+def _canonical_device(device):
+    device = torch.device(device)
+    if device.type == "cuda" and device.index is None and torch.cuda.is_available():
+        return torch.device("cuda", torch.cuda.current_device())
+    return device
+
+
+def _builtin_result_device(requested_device, dtype, selection_reason):
+    """Choose a representable result device for a CPU builtin solve."""
+
+    cpu_only_reasons = {
+        "cuda_unavailable",
+        "mps_unavailable",
+        "mps_float64_unsupported",
+    }
+    if selection_reason in cpu_only_reasons or selection_reason.startswith(
+        "unvalidated_device_"
+    ):
+        return torch.device("cpu")
+    if requested_device.type == "mps" and dtype == torch.float64:
+        warnings.warn(
+            "Builtin OSQP cannot return float64 on MPS; returning the CPU "
+            "float64 solution.",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        return torch.device("cpu")
+    return requested_device
+
+
+def _memory_limit_mb(device):
+    limit = MAX_AUTO_ESTIMATED_MEMORY_MB
+    if device.type == "cuda" and torch.cuda.is_available():
+        try:
+            total_mb = torch.cuda.get_device_properties(device).total_memory / (1024 * 1024)
+            limit = min(limit, 0.25 * total_mb)
+        except (AssertionError, RuntimeError):
+            pass
+    return float(limit)
+
+
+def _accelerator_capability(device, dtype):
+    if device.type == "cuda":
+        if not torch.cuda.is_available():
+            return False, "cuda_unavailable"
+        backend = "rocm" if torch.version.hip is not None else "cuda"
+        if not PROMOTED_ACCELERATOR_BACKENDS[backend]:
+            return False, f"{backend}_not_promoted"
+        return True, f"{backend}_promoted"
+    if device.type == "mps":
+        if dtype == torch.float64:
+            return False, "mps_float64_unsupported"
+        if not hasattr(torch.backends, "mps") or not torch.backends.mps.is_available():
+            return False, "mps_unavailable"
+        if not PROMOTED_ACCELERATOR_BACKENDS["mps"]:
+            return False, "mps_not_promoted"
+        return True, "mps_promoted"
+    return False, f"unvalidated_device_{device.type}"
+
+
+def _solve_torch_osqp_path(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    target_device,
+    dtype,
+    settings,
+    workspace,
+    allow_device_move,
+):
+    P = _torch_tensor(H, "H", target_device, dtype, allow_device_move)
+    q = _torch_tensor(f, "f", target_device, dtype, allow_device_move).reshape(-1)
+    n = q.numel()
+    if P.shape != (n, n):
+        raise ValueError(f"H must have shape {(n, n)}, got {tuple(P.shape)}.")
+    A_osqp, l_osqp, u_osqp = _build_constraints_torch(
+        A,
+        b,
+        LB,
+        UB,
+        n,
+        target_device,
+        dtype,
+        allow_device_move,
+    )
+    solve_settings = dict(settings)
+    solve_settings["return_info"] = True
+    equality_rows = 0 if A is None or b is None else int(A_osqp.shape[0] - n)
+    solve_settings["_constraint_order_signature"] = (
+        "pygranso_equalities",
+        equality_rows,
+        "variable_bounds",
+        n,
+    )
+    solution, info = solve_torch_osqp_direct(
+        P,
+        q,
+        A_osqp,
+        l_osqp,
+        u_osqp,
+        solve_settings,
+        workspace,
+    )
+    return solution.to(device=target_device, dtype=dtype), info
+
+
+def _solve_builtin_osqp_path(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    result_device,
+    requested_device,
+    dtype,
+    settings,
+    workspace,
+):
+    osqp = _import_osqp()
+    H_np = _to_numpy(H).astype(np.float64, copy=False)
+    f_np = _to_numpy(f).reshape(-1).astype(np.float64, copy=False)
+    LB_np = _to_numpy(LB).reshape(-1, 1).astype(np.float64, copy=False)
+    UB_np = _to_numpy(UB).reshape(-1, 1).astype(np.float64, copy=False)
+    n = f_np.size
+    if H_np.shape != (n, n):
+        raise ValueError(f"H must have shape {(n, n)}, got {H_np.shape}.")
+    if LB_np.shape != (n, 1) or UB_np.shape != (n, 1):
+        raise ValueError("LB and UB must be column vectors with len(f) rows.")
+    if not np.all(np.isfinite(H_np)) or not np.all(np.isfinite(f_np)):
+        raise ValueError("H and f must contain finite values.")
+    asymmetry = np.linalg.norm(H_np - H_np.T, ord=np.inf)
+    scale = max(1.0, np.linalg.norm(H_np, ord=np.inf))
+    input_epsilon = np.finfo(
+        np.float64 if dtype == torch.float64 else np.float32
+    ).eps
+    tolerance = settings["symmetry_tolerance_multiplier"] * input_epsilon * scale
+    if asymmetry > tolerance:
+        raise ValueError("H is materially asymmetric for the builtin OSQP route.")
+    H_np = 0.5 * (H_np + H_np.T)
+    P = sparse.triu(sparse.csc_matrix(H_np), format="csc")
+    A_osqp, l_osqp, u_osqp = _build_constraints_numpy(A, b, LB_np, UB_np, n)
+    if np.any(np.isnan(l_osqp)) or np.any(np.isnan(u_osqp)) or np.any(l_osqp > u_osqp):
+        raise ValueError("Constraint bounds are invalid.")
+
+    cache = workspace.builtin_cache
+    cache_hit = bool(
+        cache
+        and _same_csc_structure(cache["P"], P)
+        and _same_csc_structure(cache["A"], A_osqp)
+    )
+    builtin_settings = _builtin_settings(settings)
+    if cache_hit:
+        problem = cache["problem"]
+        updates = {"q": f_np, "l": l_osqp, "u": u_osqp}
+        if not np.array_equal(cache["P"].data, P.data):
+            updates["Px"] = P.data
+        if not np.array_equal(cache["A"].data, A_osqp.data):
+            updates["Ax"] = A_osqp.data
+        problem.update(**updates)
+        previous = cache.get("result")
+        if previous is not None and previous.x is not None and previous.y is not None:
+            problem.warm_start(x=previous.x, y=previous.y)
+        workspace.builtin_stats["updates"] += 1
+    else:
+        problem = osqp.OSQP(algebra="builtin")
+        problem.setup(P, f_np, A_osqp, l_osqp, u_osqp, **builtin_settings)
+        workspace.builtin_stats["setups"] += 1
+        if cache is not None:
+            workspace.builtin_stats["rebuilds"] += 1
+    try:
+        result = problem.solve(raise_error=False)
+    except TypeError:
+        result = problem.solve()
+    workspace.builtin_cache = {
+        "problem": problem,
+        "P": P,
+        "A": A_osqp,
+        "result": result,
+    }
+    workspace.builtin_stats["last_cache_hit"] = cache_hit
+
+    primal = getattr(result, "x", None)
+    if primal is None or np.asarray(primal).size == 0:
+        raise RuntimeError("Builtin OSQP did not return a primal solution.")
+    primal = np.asarray(primal).reshape(n, 1)
+    if not np.all(np.isfinite(primal)):
+        raise RuntimeError("Builtin OSQP returned a non-finite solution.")
+    dual_solution = getattr(result, "y", None)
+    if dual_solution is None:
+        raise RuntimeError("Builtin OSQP did not return a dual solution.")
+    dual_solution = np.asarray(dual_solution, dtype=np.float64).reshape(-1)
+    if not np.all(np.isfinite(dual_solution)):
+        raise RuntimeError("Builtin OSQP returned a non-finite dual solution.")
+    x_vector = primal.reshape(-1)
+    ax = np.asarray(A_osqp @ x_vector).reshape(-1)
+    z = np.maximum(np.minimum(ax, u_osqp), l_osqp)
+    osqp_info = getattr(result, "info", None)
+    raw_status = str(getattr(osqp_info, "status", "unknown"))
+    status = raw_status.lower().replace(" ", "_")
+    status_compatible = status.startswith("solved")
+    polish_status = getattr(osqp_info, "status_polish", None)
+    polish_fallback = None
+    if (
+        settings["polishing"]
+        and status_compatible
+        and polish_status is not None
+        and int(polish_status) < 0
+    ):
+        x_vector, z, dual_solution, polish_fallback = _dense_polish_builtin(
+            H_np,
+            f_np,
+            A_osqp,
+            l_osqp,
+            u_osqp,
+            x_vector,
+            z,
+            dual_solution,
+            settings,
+        )
+        primal = x_vector.reshape(n, 1)
+        ax = np.asarray(A_osqp @ x_vector).reshape(-1)
+    metrics = _builtin_common_metrics(
+        H_np, f_np, A_osqp, x_vector, z, dual_solution, settings
+    )
+    if (
+        settings["polishing"]
+        and status_compatible
+        and polish_fallback is None
+        and (
+            metrics["primal_residual"] > metrics["eps_primal"]
+            or metrics["dual_residual"] > metrics["eps_dual"]
+        )
+    ):
+        x_vector, z, dual_solution, polish_fallback = _dense_polish_builtin(
+            H_np,
+            f_np,
+            A_osqp,
+            l_osqp,
+            u_osqp,
+            x_vector,
+            z,
+            dual_solution,
+            settings,
+        )
+        primal = x_vector.reshape(n, 1)
+        metrics = _builtin_common_metrics(
+            H_np, f_np, A_osqp, x_vector, z, dual_solution, settings
+        )
+    if (
+        status_compatible
+        and (
+            metrics["primal_residual"] > metrics["eps_primal"]
+            or metrics["dual_residual"] > metrics["eps_dual"]
+        )
+    ):
+        raise RuntimeError(
+            "Builtin OSQP returned a solved status outside the common adapter "
+            "residual contract."
+        )
+    info = {
+        "status": status,
+        "status_compatible": status_compatible,
+        "backend": "builtin",
+        "objective": metrics["objective"],
+        "primal_residual": metrics["primal_residual"],
+        "dual_residual": metrics["dual_residual"],
+        "eps_primal": metrics["eps_primal"],
+        "eps_dual": metrics["eps_dual"],
+        "solver_objective": float(getattr(osqp_info, "obj_val", np.nan)),
+        "solver_primal_residual": float(getattr(osqp_info, "prim_res", np.nan)),
+        "solver_dual_residual": float(getattr(osqp_info, "dual_res", np.nan)),
+        "admm_iterations": int(getattr(osqp_info, "iter", 0)),
+        "device": str(result_device),
+        "requested_device": str(requested_device),
+        "dtype": str(dtype),
+        "device_transfer": requested_device.type != "cpu",
+        "builtin_workspace": dict(workspace.builtin_stats),
+        "fallback": {"occurred": False},
+        "polishing": bool(settings["polishing"]),
+        "polishing_status": (
+            "dense_lu_fallback_accepted"
+            if polish_fallback is not None
+            else None
+            if polish_status is None
+            else int(polish_status)
+        ),
+        "polishing_fallback": polish_fallback,
+    }
+    return torch.from_numpy(primal).to(device=result_device, dtype=dtype), info
+
+
+def _builtin_common_metrics(H, f, A, x, z, y, settings):
+    ax = np.asarray(A @ x).reshape(-1)
+    px = H @ x
+    aty = np.asarray(A.T @ y).reshape(-1)
+    return {
+        "primal_residual": float(np.linalg.norm(ax - z, ord=np.inf)),
+        "dual_residual": float(np.linalg.norm(px + f + aty, ord=np.inf)),
+        "eps_primal": float(
+            settings["eps_abs"]
+            + settings["eps_rel"]
+            * max(np.linalg.norm(ax, ord=np.inf), np.linalg.norm(z, ord=np.inf))
+        ),
+        "eps_dual": float(
+            settings["eps_abs"]
+            + settings["eps_rel"]
+            * max(
+                np.linalg.norm(px, ord=np.inf),
+                np.linalg.norm(aty, ord=np.inf),
+                np.linalg.norm(f, ord=np.inf),
+            )
+        ),
+        "objective": float(0.5 * x @ H @ x + f @ x),
+    }
+
+
+def _dense_polish_builtin(H, f, A, l, u, x, z, y, settings):
+    polish_settings = dict(settings)
+    x_t, z_t, y_t, info = _polish_solution(
+        torch.from_numpy(H.copy()),
+        torch.from_numpy(f.copy()),
+        torch.from_numpy(A.toarray()),
+        torch.from_numpy(l.copy()),
+        torch.from_numpy(u.copy()),
+        torch.from_numpy(x.copy()),
+        torch.from_numpy(z.copy()),
+        torch.from_numpy(y.copy()),
+        polish_settings,
+    )
+    if not info["polishing_success"]:
+        raise RuntimeError(
+            "Requested builtin OSQP polishing failed and the validated "
+            "dense-LU polish fallback did not succeed."
+        )
+    return x_t.numpy(), z_t.numpy(), y_t.numpy(), info
+
+
+def _normalize_options(options, dtype):
+    options = options or {}
+    algebra = options.get("algebra", "auto")
+    if algebra not in {"auto", "builtin", "torch"}:
+        raise ValueError("osqp_algebra must be 'auto', 'builtin', or 'torch'.")
+    user_settings = options.get("settings") or {}
+    if not isinstance(user_settings, dict):
+        raise ValueError("osqp settings must be a dict.")
+    legacy = sorted(LEGACY_TORCH_SETTINGS.intersection(user_settings))
+    if legacy:
+        warnings.warn(
+            "Sparse-CG and CUDA Graph Torch OSQP settings are deprecated and "
+            "archived. Remove them and select osqp_algebra='torch'.",
+            FutureWarning,
+            stacklevel=3,
+        )
+        raise ValueError(
+            "Archived Torch OSQP settings are no longer executable: "
+            + ", ".join(legacy)
+            + ". Remove these keys; the Torch route now uses one validated direct backend."
+        )
+    settings = _default_settings(dtype)
+    for key, value in user_settings.items():
+        normalized = "polishing" if key == "polish" else key
+        if key == "polish":
+            warnings.warn(
+                "OSQP setting 'polish' is deprecated; use 'polishing'.",
+                FutureWarning,
+                stacklevel=3,
+            )
+        if normalized not in settings:
+            raise ValueError(f"Unsupported common OSQP setting {key!r}.")
+        settings[normalized] = value
+    _validate_settings(settings)
+    return {"algebra": algebra, "settings": settings}
+
+
+def _default_settings(dtype):
+    settings = dict(DEFAULT_OSQP_SETTINGS)
+    tolerance = 1e-8 if dtype == torch.float64 else 1e-5
+    settings["eps_abs"] = tolerance
+    settings["eps_rel"] = tolerance
+    return settings
+
+
+def _validate_settings(settings):
+    settings["rho"] = _positive_float(settings["rho"], "rho")
+    settings["sigma"] = _positive_float(settings["sigma"], "sigma")
+    settings["alpha"] = _positive_float(settings["alpha"], "alpha")
+    if settings["alpha"] >= 2:
+        raise ValueError("alpha must be in (0, 2).")
+    settings["max_iter"] = _positive_int(settings["max_iter"], "max_iter")
+    settings["eps_abs"] = _nonnegative_float(settings["eps_abs"], "eps_abs")
+    settings["eps_rel"] = _nonnegative_float(settings["eps_rel"], "eps_rel")
+    settings["check_termination"] = _positive_int(
+        settings["check_termination"], "check_termination"
+    )
+    settings["scaling"] = _nonnegative_int(settings["scaling"], "scaling")
+    settings["adaptive_rho"] = bool(settings["adaptive_rho"])
+    settings["rho_update_interval"] = _positive_int(
+        settings["rho_update_interval"], "rho_update_interval"
+    )
+    settings["rho_update_tolerance"] = _positive_float(
+        settings["rho_update_tolerance"], "rho_update_tolerance"
+    )
+    settings["warm_start"] = bool(settings["warm_start"])
+    settings["polishing"] = bool(settings["polishing"])
+    settings["polish_delta"] = _positive_float(settings["polish_delta"], "polish_delta")
+    settings["polish_refine_iter"] = _nonnegative_int(
+        settings["polish_refine_iter"], "polish_refine_iter"
+    )
+    settings["symmetry_tolerance_multiplier"] = _positive_float(
+        settings["symmetry_tolerance_multiplier"], "symmetry_tolerance_multiplier"
+    )
+    for key in (
+        "check_linear_residual",
+        "check_convexity",
+        "check_condition",
+        "return_state",
+        "return_info",
+        "verbose",
+    ):
+        settings[key] = bool(settings[key])
+
+
+def _builtin_settings(settings):
+    return {
+        "rho": settings["rho"],
+        "sigma": settings["sigma"],
+        "alpha": settings["alpha"],
+        "max_iter": settings["max_iter"],
+        "eps_abs": settings["eps_abs"],
+        "eps_rel": settings["eps_rel"],
+        "check_termination": settings["check_termination"],
+        "scaling": settings["scaling"],
+        "adaptive_rho": settings["adaptive_rho"],
+        "adaptive_rho_interval": settings["rho_update_interval"],
+        "adaptive_rho_tolerance": settings["rho_update_tolerance"],
+        "warm_starting": settings["warm_start"],
+        "polishing": settings["polishing"],
+        "verbose": settings["verbose"],
+    }
+
+
+def _build_constraints_torch(A, b, LB, UB, n, device, dtype, allow_device_move):
+    lower = _torch_tensor(LB, "LB", device, dtype, allow_device_move).reshape(-1)
+    upper = _torch_tensor(UB, "UB", device, dtype, allow_device_move).reshape(-1)
+    if lower.numel() != n or upper.numel() != n:
+        raise ValueError("LB and UB must have len(f) entries.")
+    identity = torch.eye(n, device=device, dtype=dtype)
+    if A is None or b is None:
+        return identity, lower, upper
+    equality = _torch_tensor(A, "A", device, dtype, allow_device_move)
+    if equality.ndim == 1:
+        equality = equality.reshape(1, -1)
+    if equality.ndim != 2 or equality.shape[1] != n:
+        raise ValueError(f"A must have {n} columns.")
+    rhs = _torch_rhs(b, device, dtype, allow_device_move).reshape(-1)
+    if rhs.numel() == 1 and equality.shape[0] != 1:
+        rhs = rhs.expand(equality.shape[0])
+    if rhs.numel() != equality.shape[0]:
+        raise ValueError("b must be scalar or have one entry per row of A.")
+    return (
+        torch.cat((equality, identity), dim=0),
+        torch.cat((rhs, lower), dim=0),
+        torch.cat((rhs, upper), dim=0),
+    )
+
+
+def _build_constraints_numpy(A, b, LB, UB, n):
+    identity = sparse.eye(n, format="csc")
+    if A is None or b is None:
+        return identity, LB.reshape(-1), UB.reshape(-1)
+    equality = _to_numpy(A)
+    if equality.ndim == 1:
+        equality = equality.reshape(1, -1)
+    if equality.ndim != 2 or equality.shape[1] != n:
+        raise ValueError(f"A must have {n} columns.")
+    rhs = _to_numpy(b).reshape(-1)
+    if rhs.size == 1 and equality.shape[0] != 1:
+        rhs = np.full(equality.shape[0], float(rhs[0]))
+    if rhs.size != equality.shape[0]:
+        raise ValueError("b must be scalar or have one entry per row of A.")
+    return (
+        sparse.vstack((sparse.csc_matrix(equality), identity), format="csc"),
+        np.concatenate((rhs, LB.reshape(-1))),
+        np.concatenate((rhs, UB.reshape(-1))),
+    )
+
+
+def _torch_tensor(value, name, device, dtype, allow_device_move):
+    if not torch.is_tensor(value):
+        raise TypeError(f"{name} must be a Torch tensor for the Torch OSQP route.")
+    tensor = value.detach()
+    if tensor.layout != torch.strided:
+        tensor = tensor.to_dense()
+    if tensor.device != device:
+        if not allow_device_move:
+            raise ValueError(f"{name} must be on {device}, got {tensor.device}.")
+        tensor = tensor.to(device=device)
+    if tensor.dtype != dtype:
+        raise ValueError(f"{name} must use {dtype}, got {tensor.dtype}.")
+    return tensor
+
+
+def _torch_rhs(value, device, dtype, allow_device_move):
+    if torch.is_tensor(value):
+        return _torch_tensor(value, "b", device, dtype, allow_device_move)
+    if isinstance(value, Number):
+        return torch.tensor(value, device=device, dtype=dtype)
+    return torch.as_tensor(value, device=device, dtype=dtype)
+
+
+def _to_numpy(value):
+    if torch.is_tensor(value):
+        tensor = value.detach().cpu()
+        if tensor.layout != torch.strided:
+            tensor = tensor.to_dense()
+        return tensor.numpy()
+    return np.asarray(value)
+
+
+def _validate_torch_input_compatibility(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    *,
+    expected_dtype,
+):
+    tensors = [
+        (name, value)
+        for name, value in (
+            ("H", H),
+            ("f", f),
+            ("A", A),
+            ("b", b),
+            ("LB", LB),
+            ("UB", UB),
+        )
+        if torch.is_tensor(value)
+    ]
+    if not tensors:
+        return
+    reference_device = tensors[0][1].device
+    for name, tensor in tensors:
+        if tensor.device != reference_device:
+            raise ValueError(
+                "Torch QP inputs must share one device; "
+                f"{name} is on {tensor.device}, expected {reference_device}."
+            )
+        if tensor.dtype != expected_dtype:
+            raise ValueError(
+                "Torch QP inputs must match the requested precision; "
+                f"{name} uses {tensor.dtype}, expected {expected_dtype}."
+            )
+
+
+def _same_csc_structure(left, right):
+    return (
+        left.shape == right.shape
+        and np.array_equal(left.indptr, right.indptr)
+        and np.array_equal(left.indices, right.indices)
+    )
+
+
+def _import_osqp():
+    try:
+        return importlib.import_module("osqp")
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError("Install the OSQP Python package for builtin solves.") from exc
+
+
+def reset_builtin_osqp_workspace(workspace=None):
+    if workspace is not None:
+        workspace.reset_builtin()
+
+
+def get_builtin_osqp_workspace_stats(workspace=None):
+    if workspace is None:
+        return {"setups": 0, "updates": 0, "rebuilds": 0, "last_cache_hit": False}
+    return dict(workspace.builtin_stats)
+
+
+def _positive_float(value, name):
+    value = _float(value, name)
+    if value <= 0:
+        raise ValueError(f"{name} must be positive.")
+    return value
+
+
+def _nonnegative_float(value, name):
+    value = _float(value, name)
+    if value < 0:
+        raise ValueError(f"{name} must be nonnegative.")
+    return value
+
+
+def _float(value, name):
+    if isinstance(value, bool) or not isinstance(value, Number):
+        raise ValueError(f"{name} must be numeric.")
+    return float(value)
+
+
+def _positive_int(value, name):
+    if isinstance(value, bool) or not isinstance(value, Integral) or int(value) <= 0:
+        raise ValueError(f"{name} must be a positive integer.")
+    return int(value)
+
+
+def _nonnegative_int(value, name):
+    if isinstance(value, bool) or not isinstance(value, Integral) or int(value) < 0:
+        raise ValueError(f"{name} must be a nonnegative integer.")
+    return int(value)
diff --git a/pygranso/private/osqpWorkspace.py b/pygranso/private/osqpWorkspace.py
new file mode 100644
index 0000000..8c3e569
--- /dev/null
+++ b/pygranso/private/osqpWorkspace.py
@@ -0,0 +1,79 @@
+"""Optimizer-owned state for builtin and Torch OSQP routes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import torch
+
+from pygranso.private.torchLinearSolve import DenseLUSolver
+
+
+@dataclass
+class TorchOSQPWorkspace:
+    """State that must not be shared between independent PyGRANSO runs."""
+
+    state: dict | None = None
+    problem_signature: tuple | None = None
+    constraint_order_signature: tuple | None = None
+    p_pattern: torch.Tensor | None = None
+    a_pattern: torch.Tensor | None = None
+    scaling: dict | None = None
+    scaling_source_p: torch.Tensor | None = None
+    scaling_source_a: torch.Tensor | None = None
+    scaling_passes: int = 0
+    rho_bar: float | None = None
+    rho_setting: float | None = None
+    active_backend: str | None = None
+    linear_solver: DenseLUSolver = field(default_factory=DenseLUSolver)
+    last_info: dict | None = None
+    builtin_cache: dict | None = None
+    builtin_stats: dict = field(
+        default_factory=lambda: {
+            "setups": 0,
+            "updates": 0,
+            "rebuilds": 0,
+            "last_cache_hit": False,
+        }
+    )
+
+    def reset_torch(self) -> None:
+        self.state = None
+        self.problem_signature = None
+        self.constraint_order_signature = None
+        self.p_pattern = None
+        self.a_pattern = None
+        self.scaling = None
+        self.scaling_source_p = None
+        self.scaling_source_a = None
+        self.scaling_passes = 0
+        self.rho_bar = None
+        self.rho_setting = None
+        self.linear_solver.clear()
+        self.last_info = None
+
+    def reset_builtin(self) -> None:
+        self.builtin_cache = None
+        self.builtin_stats = {
+            "setups": 0,
+            "updates": 0,
+            "rebuilds": 0,
+            "last_cache_hit": False,
+        }
+
+    def reset(self) -> None:
+        self.reset_torch()
+        self.reset_builtin()
+        self.active_backend = None
+
+    def ensure_backend(self, backend: str) -> bool:
+        """Invalidate all cached state when a run changes QP backend."""
+
+        if backend not in {"builtin", "torch"}:
+            raise ValueError(f"Unknown workspace backend {backend!r}.")
+        changed = self.active_backend is not None and self.active_backend != backend
+        if changed:
+            self.reset_torch()
+            self.reset_builtin()
+        self.active_backend = backend
+        return changed
diff --git a/pygranso/private/qpSteeringStrategy.py b/pygranso/private/qpSteeringStrategy.py
index fcec111..034fdea 100644
--- a/pygranso/private/qpSteeringStrategy.py
+++ b/pygranso/private/qpSteeringStrategy.py
@@ -22,6 +22,7 @@ def qpSteeringStrategy(
         QPsolver,
         torch_device,
         double_precision,
+        osqp_options=None,
     ):
         """
         qpSteeringStrategy:
@@ -145,6 +146,7 @@ def qpSteeringStrategy(
         else:
             self.torch_dtype = torch.float
         self.QPsolver = QPsolver
+        self.osqp_options = osqp_options
         mu = penaltyfn_at_x.mu
         f_grad = penaltyfn_at_x.f_grad
         self.ineq = penaltyfn_at_x.ci
@@ -305,13 +307,14 @@ def solveSteeringDualQP(self):
                     "osqp",
                     self.device,
                     self.double_precision,
+                    self.osqp_options,
                 )
         except Exception:
             print(
                 "PyGRANSO steeringQuadprogFailure: Steering aborted due to a quadprog failure."
             )
             print(traceback.format_exc())
-            # sys.exit()
+            raise
 
         d = -self.mu_Hinv_f_grad - (self.Hinv_c_grads @ y)
         return d
diff --git a/pygranso/private/qpTerminationCondition.py b/pygranso/private/qpTerminationCondition.py
index b1046a7..c2731b4 100644
--- a/pygranso/private/qpTerminationCondition.py
+++ b/pygranso/private/qpTerminationCondition.py
@@ -16,6 +16,7 @@ def qpTerminationCondition(
         QPsolver,
         torch_device,
         double_precision,
+        osqp_options=None,
     ):
         """
         qpTerminationCondition:
@@ -176,7 +177,7 @@ def qpTerminationCondition(
                 torch.zeros((1, p), device=torch_device, dtype=torch_dtype),
             )
         )
-        beq = mu
+        beq = torch.as_tensor(mu, device=torch_device, dtype=torch_dtype)
 
         # Choose solver
         if QPsolver == "gurobi":
@@ -187,7 +188,16 @@ def qpTerminationCondition(
         elif QPsolver == "osqp":
             #  formulation of QP has no 1/2
             self.solveQP_fn = lambda H: solveQP(
-                H, f, Aeq, beq, LB, UB, QPsolver, torch_device, double_precision
+                H,
+                f,
+                Aeq,
+                beq,
+                LB,
+                UB,
+                QPsolver,
+                torch_device,
+                double_precision,
+                osqp_options,
             )
 
         [y, _, qps_solved, ME] = self.solveQPRobust(torch_dtype)
@@ -206,17 +216,17 @@ def qpTerminationCondition(
     def solveQPRobust(self, torch_dtype):
         x = None
         lambdas = None  # not used here
-        ME = None  # ignore other 3 Fall back strategies for now
+        ME = []
 
         #  Attempt to solve QP
         try:
             stat_type = 1
             x = self.solveQP_fn(self.H)
             return [x, lambdas, stat_type, ME]
-        except Exception:
+        except Exception as exc:
             # print("PyGRANSO:qpTerminationCondition type 1 failure")
             # print(traceback.format_exc())
-            pass
+            ME.append(exc)
 
         #  QP solver failed, possibly because H was numerically nonconvex,
         #  i.e. H may have tiny negative eigenvalues close to zero because
@@ -229,10 +239,10 @@ def solveQPRobust(self, torch_dtype):
             R = (R + torch.conj(R.T)) / 2
             x = self.solveQP_fn(R)
             return [x, lambdas, stat_type, ME]
-        except Exception:
+        except Exception as exc:
             # print("PyGRANSO:qpTerminationCondition type 2 failure")
             # print(traceback.format_exc())
-            pass
+            ME.append(exc)
 
         # % Fall back strategy #2: revert to MATLAB's quadprog, if user is
         # % using a different quadprog solver and reattempt with original H
@@ -256,7 +266,12 @@ def solveQPRobust(self, torch_dtype):
             Hreg = torch.conj(V.T) @ torch.diag(dvec) @ torch.conj(V.T)
             x = self.solveQP_fn(Hreg)
             return [x, lambdas, stat_type, ME]
-        except Exception:
+        except Exception as exc:
             # print("PyGRANSO:qpTerminationCondition type 4 failure")
             # print(traceback.format_exc())
-            pass
+            ME.append(exc)
+
+        # Preserve PyGRANSO's outer stationarity fallback contract. Returning
+        # x=None causes qpTerminationCondition() to construct an infinite
+        # stationarity vector instead of leaking a secondary unpacking error.
+        return [None, lambdas, 0, ME]
diff --git a/pygranso/private/solveQP.py b/pygranso/private/solveQP.py
index c556275..be0880d 100644
--- a/pygranso/private/solveQP.py
+++ b/pygranso/private/solveQP.py
@@ -1,14 +1,27 @@
 import gurobipy as gp
 import numpy as np
-import osqp
 import torch
 from gurobipy import GRB
-from scipy import sparse
-
-QP_REQUESTS = 0
 
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
 
-def solveQP(H, f, A, b, LB, UB, QPsolver, torch_device, double_precision):
+QP_REQUESTS = 0
+OSQP_TRACE = None
+
+
+def solveQP(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    QPsolver,
+    torch_device,
+    double_precision,
+    osqp_options=None,
+):
     """
     solveQP:
         Convenience wrapper for any quadprog interface QP solver.  This
@@ -91,70 +104,10 @@ def solveQP(H, f, A, b, LB, UB, QPsolver, torch_device, double_precision):
     QP_REQUESTS += 1
 
     if QPsolver == "osqp":
-        # H,f always exist
-        nvar = len(f)
-        # H and A has to be sparse
-        H = H.cpu().numpy()
-        f = f.cpu().numpy()
-        if A is not None:
-            A = A.cpu().numpy()
-        # b = b.cpu().numpy()
-        LB = LB.cpu().numpy()
-        UB = UB.cpu().numpy()
-        H_sparse = sparse.csc_matrix(H)
-        # LB and UB always exist
-
-        if np.any(A is not None) and np.any(b is not None):
-            Aeq = A
-            beq = b
-            speye = sparse.eye(nvar)
-            LB_new = np.vstack((beq, LB))
-            UB_new = np.vstack((beq, UB))
-            A_new = sparse.vstack([Aeq, speye])
-            A_new = sparse.csc_matrix(A_new)
-        else:
-            #  no constraint A*x == b
-            A_new = sparse.eye(nvar)
-            A_new = sparse.csc_matrix(A_new)
-            LB_new = LB
-            UB_new = UB
-
-        # # Create an OSQP object
-        # # Set algebra based on device type
-        # if str(torch_device).startswith("cuda"):
-        #     algebra_type = "cuda"
-        # else:
-        #     algebra_type = "builtin"
-        # prob = osqp.OSQP(algebra=algebra_type)
-
-        prob = osqp.OSQP(algebra="builtin")
-
-        # Setup workspace and change alpha parameter
-        prob.setup(
-            H_sparse,
-            f,
-            A_new,
-            LB_new,
-            UB_new,
-            eps_abs=1e-12,
-            eps_rel=1e-12,
-            polish=True,
-            verbose=False,
+        _record_osqp_qp(H, f, A, b, LB, UB)
+        return _solve_osqp_with_warm_state(
+            H, f, A, b, LB, UB, torch_device, double_precision, osqp_options
         )
-        # prob.setup(H_sparse, f, A_new, LB_new, UB_new, alpha=1.0,verbose=False)
-
-        # Solve problem
-        res = prob.solve()
-
-        solution = res.x
-        sol_len = solution.size
-        solution = solution.reshape((sol_len, 1))
-        if double_precision:
-            torch_dtype = torch.double
-        else:
-            torch_dtype = torch.float
-        solution = torch.from_numpy(solution).to(device=torch_device, dtype=torch_dtype)
-        return solution
 
     if QPsolver == "gurobi":
         H = H.cpu().numpy()
@@ -220,3 +173,156 @@ def getErr():
     global QP_REQUESTS
     errors = 0
     return [QP_REQUESTS, errors]
+
+
+def getLastOSQPInfo(workspace=None):
+    return None if workspace is None else workspace.last_info
+
+
+def beginOSQPTrace(capture_data=True):
+    global OSQP_TRACE
+    OSQP_TRACE = {"capture_data": bool(capture_data), "records": []}
+
+
+def endOSQPTrace():
+    global OSQP_TRACE
+    trace = [] if OSQP_TRACE is None else OSQP_TRACE["records"]
+    OSQP_TRACE = None
+    return trace
+
+
+def _record_osqp_qp(H, f, A, b, LB, UB):
+    if OSQP_TRACE is None:
+        return
+    tensors = {"H": H, "f": f, "A": A, "b": b, "LB": LB, "UB": UB}
+    previous = OSQP_TRACE["records"][-1] if OSQP_TRACE["records"] else None
+    record = {
+        "index": len(OSQP_TRACE["records"]),
+        "n": int(f.numel()),
+        "H": _trace_tensor_metadata(H),
+        "A": _trace_tensor_metadata(A),
+    }
+    if OSQP_TRACE["capture_data"]:
+        record["qp"] = tuple(
+            None
+            if tensor is None
+            else tensor.detach().cpu().clone()
+            if torch.is_tensor(tensor)
+            else torch.as_tensor(tensor).detach().cpu().clone()
+            for tensor in tensors.values()
+        )
+    if previous is None or "qp" not in previous or "qp" not in record:
+        record["structure_changed"] = previous is not None
+        record["matrix_values_changed"] = previous is not None
+    else:
+        previous_H, _previous_f, previous_A, _previous_b, _previous_LB, _previous_UB = (
+            previous["qp"]
+        )
+        current_H, _current_f, current_A, _current_b, _current_LB, _current_UB = record[
+            "qp"
+        ]
+        structure_same = _same_tensor_structure(previous_H, current_H) and (
+            (previous_A is None and current_A is None)
+            or _same_tensor_structure(previous_A, current_A)
+        )
+        record["structure_changed"] = not structure_same
+        record["matrix_values_changed"] = not (
+            _same_tensor_values(previous_H, current_H)
+            and (
+                (previous_A is None and current_A is None)
+                or _same_tensor_values(previous_A, current_A)
+            )
+        )
+    OSQP_TRACE["records"].append(record)
+
+
+def _trace_tensor_metadata(tensor):
+    if tensor is None:
+        return None
+    nnz = (
+        int(torch.count_nonzero(tensor).item())
+        if tensor.layout == torch.strided
+        else int(tensor._nnz())
+    )
+    return {
+        "shape": tuple(tensor.shape),
+        "layout": str(tensor.layout),
+        "dtype": str(tensor.dtype),
+        "device": str(tensor.device),
+        "nnz": nnz,
+    }
+
+
+def _same_tensor_structure(left, right):
+    if left is None or right is None:
+        return left is right
+    if left.shape != right.shape or left.layout != right.layout:
+        return False
+    if left.layout == torch.strided:
+        return True
+    left_csr = left if left.layout == torch.sparse_csr else left.to_sparse_csr()
+    right_csr = right if right.layout == torch.sparse_csr else right.to_sparse_csr()
+    return torch.equal(left_csr.crow_indices(), right_csr.crow_indices()) and torch.equal(
+        left_csr.col_indices(), right_csr.col_indices()
+    )
+
+
+def _same_tensor_values(left, right):
+    if not _same_tensor_structure(left, right):
+        return False
+    if left.layout == torch.strided:
+        return torch.equal(left, right)
+    left_csr = left if left.layout == torch.sparse_csr else left.to_sparse_csr()
+    right_csr = right if right.layout == torch.sparse_csr else right.to_sparse_csr()
+    return torch.equal(left_csr.values(), right_csr.values())
+
+
+def resetOSQPWarmState(workspace=None):
+    if workspace is not None:
+        workspace.reset()
+
+
+def _solve_osqp_with_warm_state(
+    H,
+    f,
+    A,
+    b,
+    LB,
+    UB,
+    torch_device,
+    double_precision,
+    osqp_options,
+):
+    options = _copy_osqp_options(osqp_options)
+    workspace = options.pop("workspace", None)
+    if workspace is None:
+        workspace = TorchOSQPWorkspace()
+    if not isinstance(workspace, TorchOSQPWorkspace):
+        raise TypeError("osqp_options['workspace'] must be a TorchOSQPWorkspace.")
+    settings = options.setdefault("settings", {})
+    requested_return_info = bool(settings.get("return_info", False))
+    settings["return_info"] = True
+    result = solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        LB,
+        UB,
+        torch_device,
+        double_precision,
+        options,
+        workspace,
+    )
+    solution, info = result
+    workspace.last_info = info
+    return (solution, info) if requested_return_info else solution
+
+
+def _copy_osqp_options(osqp_options):
+    if osqp_options is None:
+        return {}
+    options = dict(osqp_options)
+    if isinstance(options.get("settings"), dict):
+        options["settings"] = dict(options["settings"])
+    return options
diff --git a/pygranso/private/torchLinearSolve.py b/pygranso/private/torchLinearSolve.py
new file mode 100644
index 0000000..0fe7b5a
--- /dev/null
+++ b/pygranso/private/torchLinearSolve.py
@@ -0,0 +1,197 @@
+"""Validated PyTorch-native dense linear-system factorization and solves."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+
+
+class TorchLinearSolveError(RuntimeError):
+    """Raised when PyTorch cannot factor or solve a validated linear system."""
+
+
+@dataclass(frozen=True)
+class LinearSolveDiagnostics:
+    solver: str
+    factorization_info: int
+    factorization_count: int
+    solve_count: int
+    linear_residual_norm: float | None = None
+    relative_linear_residual: float | None = None
+
+    def as_dict(self) -> dict:
+        return {
+            "solver": self.solver,
+            "factorization_info": self.factorization_info,
+            "factorization_count": self.factorization_count,
+            "solve_count": self.solve_count,
+            "linear_residual_norm": self.linear_residual_norm,
+            "relative_linear_residual": self.relative_linear_residual,
+        }
+
+
+class DenseLUSolver:
+    """Cache a dense LU factorization and solve repeated right-hand sides."""
+
+    solver_name = "torch.linalg.lu_factor_ex/lu_solve"
+
+    def __init__(self) -> None:
+        self._matrix: torch.Tensor | None = None
+        self._lu: torch.Tensor | None = None
+        self._pivots: torch.Tensor | None = None
+        self._info = 0
+        self.factorization_count = 0
+        self.solve_count = 0
+
+    @property
+    def ready(self) -> bool:
+        return self._lu is not None and self._pivots is not None
+
+    @property
+    def matrix(self) -> torch.Tensor | None:
+        return self._matrix
+
+    def clear(self) -> None:
+        self._matrix = None
+        self._lu = None
+        self._pivots = None
+        self._info = 0
+
+    def is_factorized_for(self, matrix: torch.Tensor) -> bool:
+        if not self.ready or self._matrix is None:
+            return False
+        return (
+            self._matrix.shape == matrix.shape
+            and self._matrix.device == matrix.device
+            and self._matrix.dtype == matrix.dtype
+            and torch.equal(self._matrix, matrix)
+        )
+
+    def factorize(self, matrix: torch.Tensor) -> None:
+        matrix = _validate_matrix(matrix)
+        try:
+            lu, pivots, info = torch.linalg.lu_factor_ex(
+                matrix,
+                check_errors=False,
+            )
+        except (NotImplementedError, RuntimeError) as exc:
+            raise TorchLinearSolveError(
+                f"PyTorch LU factorization is unavailable or failed on "
+                f"{matrix.device}: {exc}"
+            ) from exc
+
+        info_value = int(info.detach().cpu().item())
+        if info_value != 0:
+            raise TorchLinearSolveError(
+                "PyTorch LU factorization reported a singular or invalid "
+                f"matrix (info={info_value})."
+            )
+        if not bool(torch.all(torch.isfinite(lu)).item()):
+            raise TorchLinearSolveError(
+                "PyTorch LU factorization returned non-finite factors."
+            )
+
+        self._matrix = matrix.detach().clone()
+        self._lu = lu
+        self._pivots = pivots
+        self._info = info_value
+        self.factorization_count += 1
+
+    def refactorize(self, matrix: torch.Tensor) -> None:
+        self.factorize(matrix)
+
+    def factorize_if_needed(self, matrix: torch.Tensor) -> bool:
+        if self.is_factorized_for(matrix):
+            return False
+        self.factorize(matrix)
+        return True
+
+    def solve(
+        self,
+        rhs: torch.Tensor,
+        *,
+        calculate_residual: bool = False,
+    ) -> tuple[torch.Tensor, dict]:
+        if not self.ready or self._matrix is None:
+            raise TorchLinearSolveError(
+                "The linear solver must be factorized before solve()."
+            )
+        rhs, vector_rhs = _validate_rhs(rhs, self._matrix)
+        try:
+            solution = torch.linalg.lu_solve(self._lu, self._pivots, rhs)
+        except (NotImplementedError, RuntimeError) as exc:
+            raise TorchLinearSolveError(
+                f"PyTorch LU solve failed on {rhs.device}: {exc}"
+            ) from exc
+        if not bool(torch.all(torch.isfinite(solution)).item()):
+            raise TorchLinearSolveError(
+                "PyTorch LU solve returned a non-finite solution."
+            )
+
+        self.solve_count += 1
+        residual_norm = None
+        relative_residual = None
+        if calculate_residual:
+            residual = self._matrix @ solution - rhs
+            residual_value = torch.linalg.vector_norm(residual)
+            rhs_value = torch.linalg.vector_norm(rhs)
+            denominator = torch.maximum(
+                rhs_value,
+                torch.ones((), device=rhs.device, dtype=rhs.dtype),
+            )
+            residual_norm = float(residual_value.item())
+            relative_residual = float((residual_value / denominator).item())
+
+        diagnostics = LinearSolveDiagnostics(
+            solver=self.solver_name,
+            factorization_info=self._info,
+            factorization_count=self.factorization_count,
+            solve_count=self.solve_count,
+            linear_residual_norm=residual_norm,
+            relative_linear_residual=relative_residual,
+        ).as_dict()
+        if vector_rhs:
+            solution = solution.reshape(-1)
+        return solution, diagnostics
+
+
+def _validate_matrix(matrix: torch.Tensor) -> torch.Tensor:
+    if not torch.is_tensor(matrix):
+        raise TypeError("The linear-system matrix must be a Torch tensor.")
+    matrix = matrix.detach()
+    if matrix.layout != torch.strided:
+        raise ValueError("The dense LU solver requires a strided matrix.")
+    if matrix.ndim != 2:
+        raise ValueError("The linear-system matrix must be two-dimensional.")
+    rows, columns = matrix.shape
+    if rows != columns:
+        raise ValueError("The linear-system matrix must be square.")
+    if matrix.dtype not in {torch.float32, torch.float64}:
+        raise ValueError("The dense LU solver supports float32 and float64 only.")
+    if not bool(torch.all(torch.isfinite(matrix)).item()):
+        raise ValueError("The linear-system matrix contains NaN or Inf.")
+    return matrix
+
+
+def _validate_rhs(
+    rhs: torch.Tensor,
+    matrix: torch.Tensor,
+) -> tuple[torch.Tensor, bool]:
+    if not torch.is_tensor(rhs):
+        raise TypeError("The linear-system right-hand side must be a Torch tensor.")
+    rhs = rhs.detach()
+    if rhs.ndim not in {1, 2}:
+        raise ValueError("The right-hand side must be a vector or matrix.")
+    if rhs.shape[0] != matrix.shape[0]:
+        raise ValueError("The right-hand side is incompatible with the matrix.")
+    if rhs.device != matrix.device:
+        raise ValueError("The matrix and right-hand side must use the same device.")
+    if rhs.dtype != matrix.dtype:
+        raise ValueError("The matrix and right-hand side must use the same dtype.")
+    if not bool(torch.all(torch.isfinite(rhs)).item()):
+        raise ValueError("The linear-system right-hand side contains NaN or Inf.")
+    vector_rhs = rhs.ndim == 1
+    if vector_rhs:
+        rhs = rhs.reshape(-1, 1)
+    return rhs, vector_rhs
diff --git a/pygranso/private/torchOSQP.py b/pygranso/private/torchOSQP.py
new file mode 100644
index 0000000..1958504
--- /dev/null
+++ b/pygranso/private/torchOSQP.py
@@ -0,0 +1,656 @@
+"""Dense Torch reference implementation of OSQP's ADMM equations."""
+
+from __future__ import annotations
+
+import time
+
+import torch
+
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+from pygranso.private.torchLinearSolve import DenseLUSolver, TorchLinearSolveError
+
+
+def build_kkt_matrix(P, A, sigma, rho_vec):
+    n = P.shape[0]
+    identity = torch.eye(n, device=P.device, dtype=P.dtype)
+    top = torch.cat((P + float(sigma) * identity, A.T), dim=1)
+    bottom = torch.cat((A, -torch.diag(rho_vec.reciprocal())), dim=1)
+    return torch.cat((top, bottom), dim=0)
+
+
+def build_kkt_rhs(x, z, y, q, sigma, rho_vec):
+    return torch.cat((float(sigma) * x - q, z - y / rho_vec))
+
+
+def recover_z_tilde(z, nu, y, rho_vec):
+    return z + (nu - y) / rho_vec
+
+
+def admm_vector_update(x_tilde, x, z_tilde, z, y, rho_vec, l, u, alpha):
+    x_next = float(alpha) * x_tilde + (1.0 - float(alpha)) * x
+    z_relaxed = float(alpha) * z_tilde + (1.0 - float(alpha)) * z
+    z_next = torch.maximum(torch.minimum(z_relaxed + y / rho_vec, u), l)
+    y_next = y + rho_vec * (z_relaxed - z_next)
+    return x_next, z_next, y_next
+
+
+def solve_torch_osqp_direct(P, q, A, l, u, settings, workspace=None):
+    """Solve ``min 0.5*x'Px + q'x`` subject to ``l <= Ax <= u``."""
+
+    workspace = workspace or TorchOSQPWorkspace()
+    with torch.no_grad():
+        P, q, A, l, u = _validate_qp(P, q, A, l, u, settings)
+        _prepare_workspace(
+            workspace,
+            P,
+            A,
+            settings.get("_constraint_order_signature"),
+        )
+        scaling = _scaling_for_problem(workspace, P, q, A, settings)
+        P_s, q_s, A_s, l_s, u_s = _scale_problem(P, q, A, l, u, scaling)
+
+        n = q.numel()
+        m = l.numel()
+        x, z, y = _initial_scaled_state(
+            workspace,
+            n,
+            m,
+            q.device,
+            q.dtype,
+            scaling,
+            bool(settings.get("warm_start", True)),
+        )
+        initial_rho = (
+            workspace.rho_bar
+            if (
+                bool(settings.get("warm_start", True))
+                and workspace.rho_bar is not None
+                and workspace.rho_setting == float(settings["rho"])
+            )
+            else float(settings["rho"])
+        )
+        rho_bar = torch.as_tensor(initial_rho, device=q.device, dtype=q.dtype)
+        equality = _equality_mask(l_s, u_s)
+        rho_vec = _rho_vector(rho_bar, equality)
+        sigma = float(settings["sigma"])
+        alpha = float(settings["alpha"])
+        max_iter = int(settings["max_iter"])
+        check_termination = int(settings["check_termination"])
+        adaptive_rho = bool(settings.get("adaptive_rho", True))
+        rho_interval = int(settings.get("rho_update_interval", 50))
+        rho_tolerance = float(settings.get("rho_update_tolerance", 5.0))
+        check_linear_residual = bool(settings.get("check_linear_residual", False))
+
+        solver = workspace.linear_solver
+        factors_before = solver.factorization_count
+        solves_before = solver.solve_count
+        K = build_kkt_matrix(P_s, A_s, sigma, rho_vec)
+        factorization_reused = not solver.factorize_if_needed(K)
+        maximum_linear_residual = None
+        latest_linear_diagnostics = None
+        status = "max_iter_reached"
+        rho_updates = 0
+        last_residuals = None
+
+        for iteration in range(1, max_iter + 1):
+            rhs = build_kkt_rhs(x, z, y, q_s, sigma, rho_vec)
+            solution, linear_diagnostics = solver.solve(
+                rhs,
+                calculate_residual=check_linear_residual,
+            )
+            latest_linear_diagnostics = linear_diagnostics
+            observed = linear_diagnostics.get("relative_linear_residual")
+            if observed is not None:
+                maximum_linear_residual = (
+                    observed
+                    if maximum_linear_residual is None
+                    else max(maximum_linear_residual, observed)
+                )
+
+            x_tilde = solution[:n]
+            nu = solution[n:]
+            z_tilde = recover_z_tilde(z, nu, y, rho_vec)
+            x, z, y = admm_vector_update(
+                x_tilde,
+                x,
+                z_tilde,
+                z,
+                y,
+                rho_vec,
+                l_s,
+                u_s,
+                alpha,
+            )
+
+            should_check = iteration % check_termination == 0
+            should_update_rho = adaptive_rho and iteration % rho_interval == 0
+            if should_check or should_update_rho or iteration == max_iter:
+                x_o, z_o, y_o = _unscale_state(x, z, y, scaling)
+                last_residuals = _residuals(
+                    P,
+                    q,
+                    A,
+                    x_o,
+                    z_o,
+                    y_o,
+                    float(settings["eps_abs"]),
+                    float(settings["eps_rel"]),
+                )
+                primal, dual, eps_primal, eps_dual = last_residuals
+                if should_check and bool(
+                    ((primal <= eps_primal) & (dual <= eps_dual)).item()
+                ):
+                    status = "solved"
+                    break
+                if should_update_rho:
+                    updated, rho_bar, rho_vec = _adaptive_rho_update(
+                        rho_bar,
+                        equality,
+                        primal,
+                        dual,
+                        eps_primal,
+                        eps_dual,
+                        rho_tolerance,
+                    )
+                    if updated:
+                        rho_updates += 1
+                        K = build_kkt_matrix(P_s, A_s, sigma, rho_vec)
+                        solver.refactorize(K)
+        else:
+            iteration = max_iter
+
+        x_o, z_o, y_o = _unscale_state(x, z, y, scaling)
+        if last_residuals is None:
+            last_residuals = _residuals(
+                P,
+                q,
+                A,
+                x_o,
+                z_o,
+                y_o,
+                float(settings["eps_abs"]),
+                float(settings["eps_rel"]),
+            )
+
+        polish_info = _default_polish_info(settings)
+        if bool(settings.get("polishing", True)) and status == "solved":
+            x_o, z_o, y_o, polish_info = _polish_solution(
+                P, q, A, l, u, x_o, z_o, y_o, settings
+            )
+            if polish_info["polishing_status"] == "rejected_no_improvement":
+                raise TorchLinearSolveError(
+                    "Requested polishing failed to produce an acceptable KKT point."
+                )
+            last_residuals = _residuals(
+                P,
+                q,
+                A,
+                x_o,
+                z_o,
+                y_o,
+                float(settings["eps_abs"]),
+                float(settings["eps_rel"]),
+            )
+        elif bool(settings.get("polishing", True)):
+            polish_info["polishing_status"] = "skipped_unsolved"
+
+        workspace.state = {
+            "x": x_o.detach().clone(),
+            "z": z_o.detach().clone(),
+            "y": y_o.detach().clone(),
+        }
+        workspace.rho_bar = float(rho_bar.item())
+        workspace.rho_setting = float(settings["rho"])
+        primal, dual, eps_primal, eps_dual = last_residuals
+        objective = 0.5 * torch.dot(x_o, P @ x_o) + torch.dot(q, x_o)
+        info = {
+            "status": status,
+            "status_compatible": status == "solved",
+            "admm_iterations": int(iteration),
+            "primal_residual": float(primal.item()),
+            "dual_residual": float(dual.item()),
+            "eps_primal": float(eps_primal.item()),
+            "eps_dual": float(eps_dual.item()),
+            "objective": float(objective.item()),
+            "backend": "torch",
+            "linear_solver": DenseLUSolver.solver_name,
+            "factorization_reused": factorization_reused,
+            "factorizations_this_solve": solver.factorization_count - factors_before,
+            "linear_solves_this_solve": solver.solve_count - solves_before,
+            "factorization_count": solver.factorization_count,
+            "linear_solve_count": solver.solve_count,
+            "latest_linear_diagnostics": latest_linear_diagnostics,
+            "maximum_linear_residual": maximum_linear_residual,
+            "rho_updates": rho_updates,
+            "rho_bar": float(rho_bar.item()),
+            "rho_min": float(torch.min(rho_vec).item()),
+            "rho_max": float(torch.max(rho_vec).item()),
+            "scaling_applied": int(settings.get("scaling", 0)) > 0,
+            "scaling_passes": int(settings.get("scaling", 0)),
+            "device": str(q.device),
+            "dtype": str(q.dtype),
+            "estimated_kkt_dim": int(n + m),
+            **polish_info,
+        }
+        if bool(settings.get("check_condition", False)):
+            try:
+                info["estimated_kkt_condition"] = float(torch.linalg.cond(K).item())
+            except (NotImplementedError, RuntimeError):
+                info["estimated_kkt_condition"] = None
+        if bool(settings.get("return_state", False)):
+            info["state"] = {
+                key: value.detach().clone() for key, value in workspace.state.items()
+            }
+        workspace.last_info = dict(info)
+        solution = x_o.reshape(n, 1)
+        return (solution, info) if bool(settings.get("return_info", False)) else solution
+
+
+def solve_torch_osqp(P, q, A, l, u, settings, workspace=None):
+    return solve_torch_osqp_direct(P, q, A, l, u, settings, workspace)
+
+
+def solve_torch_osqp_dense(P, q, A, l, u, settings, workspace=None):
+    """Compatibility alias for the archived prototype name."""
+    return solve_torch_osqp_direct(P, q, A, l, u, settings, workspace)
+
+
+def _validate_qp(P, q, A, l, u, settings):
+    tensors = {
+        "P": _dense_tensor(P, "P"),
+        "q": _dense_tensor(q, "q").reshape(-1),
+        "A": _dense_tensor(A, "A"),
+        "l": _dense_tensor(l, "l").reshape(-1),
+        "u": _dense_tensor(u, "u").reshape(-1),
+    }
+    P, q, A, l, u = (tensors[key] for key in ("P", "q", "A", "l", "u"))
+    if q.dtype not in {torch.float32, torch.float64}:
+        raise ValueError("Torch OSQP supports float32 and float64 only.")
+    for name, tensor in tensors.items():
+        if tensor.device != q.device:
+            raise ValueError(f"{name} must be on {q.device}, got {tensor.device}.")
+        if tensor.dtype != q.dtype:
+            raise ValueError(f"{name} must use {q.dtype}, got {tensor.dtype}.")
+    n = q.numel()
+    m = l.numel()
+    if n == 0:
+        raise ValueError("Torch OSQP requires at least one variable.")
+    if P.shape != (n, n):
+        raise ValueError(f"P must have shape {(n, n)}, got {tuple(P.shape)}.")
+    if A.ndim != 2 or A.shape != (m, n):
+        raise ValueError(f"A must have shape {(m, n)}, got {tuple(A.shape)}.")
+    if u.numel() != m:
+        raise ValueError("l and u must have the same number of entries.")
+    for name, tensor in (("P", P), ("q", q), ("A", A)):
+        if not bool(torch.all(torch.isfinite(tensor)).item()):
+            raise ValueError(f"{name} contains NaN or Inf.")
+    if bool(torch.any(torch.isnan(l)).item()) or bool(torch.any(torch.isnan(u)).item()):
+        raise ValueError("l and u must not contain NaN.")
+    if bool(torch.any(l > u).item()):
+        raise ValueError("Every lower bound must be less than or equal to its upper bound.")
+
+    eps = torch.finfo(q.dtype).eps
+    multiplier = float(settings.get("symmetry_tolerance_multiplier", 100.0))
+    scale = max(1.0, float(torch.linalg.matrix_norm(P, ord=float("inf")).item()))
+    asymmetry = float(torch.linalg.matrix_norm(P - P.T, ord=float("inf")).item())
+    tolerance = multiplier * eps * scale
+    if asymmetry > tolerance:
+        raise ValueError(
+            "P is materially asymmetric: "
+            f"||P-P.T||_inf={asymmetry:.3e} exceeds {tolerance:.3e}."
+        )
+    P = 0.5 * (P + P.T)
+    if bool(settings.get("check_convexity", False)):
+        eigenvalues = torch.linalg.eigvalsh(P)
+        spectral_scale = max(1.0, float(torch.max(torch.abs(eigenvalues)).item()))
+        psd_tolerance = multiplier * eps * spectral_scale
+        minimum = float(torch.min(eigenvalues).item())
+        if minimum < -psd_tolerance:
+            raise ValueError(
+                f"P is not positive semidefinite: lambda_min={minimum:.3e}, "
+                f"tolerance={psd_tolerance:.3e}."
+            )
+    return P, q, A, l, u
+
+
+def _dense_tensor(value, name):
+    if not torch.is_tensor(value):
+        raise TypeError(f"{name} must be a Torch tensor.")
+    tensor = value.detach()
+    return tensor.to_dense() if tensor.layout != torch.strided else tensor
+
+
+def _prepare_workspace(workspace, P, A, constraint_order_signature=None):
+    signature = (tuple(P.shape), tuple(A.shape), str(P.device), str(P.dtype), "torch")
+    p_pattern = P.ne(0)
+    a_pattern = A.ne(0)
+    compatible = (
+        workspace.problem_signature == signature
+        and workspace.constraint_order_signature == constraint_order_signature
+        and workspace.p_pattern is not None
+        and workspace.a_pattern is not None
+        and torch.equal(workspace.p_pattern, p_pattern)
+        and torch.equal(workspace.a_pattern, a_pattern)
+    )
+    if not compatible:
+        workspace.reset_torch()
+        workspace.problem_signature = signature
+        workspace.constraint_order_signature = constraint_order_signature
+        workspace.p_pattern = p_pattern.detach().clone()
+        workspace.a_pattern = a_pattern.detach().clone()
+        return
+    scaling_matches = (
+        workspace.scaling_source_p is not None
+        and workspace.scaling_source_a is not None
+        and torch.equal(workspace.scaling_source_p, P)
+        and torch.equal(workspace.scaling_source_a, A)
+    )
+    if not scaling_matches:
+        workspace.scaling = None
+        workspace.scaling_source_p = None
+        workspace.scaling_source_a = None
+        workspace.scaling_passes = 0
+
+
+def _scaling_for_problem(workspace, P, q, A, settings):
+    passes = int(settings.get("scaling", 0))
+    if passes <= 0:
+        return {
+            "D": torch.ones(P.shape[0], device=P.device, dtype=P.dtype),
+            "E": torch.ones(A.shape[0], device=A.device, dtype=A.dtype),
+            "cost": torch.ones((), device=P.device, dtype=P.dtype),
+            "passes": 0,
+        }
+    if workspace.scaling is not None and workspace.scaling_passes == passes:
+        return workspace.scaling
+    tiny = torch.as_tensor(torch.finfo(P.dtype).tiny, device=P.device, dtype=P.dtype)
+    D = torch.ones(P.shape[0], device=P.device, dtype=P.dtype)
+    E = torch.ones(A.shape[0], device=A.device, dtype=A.dtype)
+    P_work = P.clone()
+    A_work = A.clone()
+    q_work = q.clone()
+    for _ in range(passes):
+        p_norm = torch.maximum(
+            torch.amax(torch.abs(P_work), dim=0),
+            torch.amax(torch.abs(P_work), dim=1),
+        )
+        a_col = torch.amax(torch.abs(A_work), dim=0)
+        a_row = torch.amax(torch.abs(A_work), dim=1)
+        d_step = torch.rsqrt(torch.maximum(p_norm, a_col).clamp_min(tiny))
+        e_step = torch.rsqrt(a_row.clamp_min(tiny))
+        d_step = d_step.clamp(0.1, 10.0)
+        e_step = e_step.clamp(0.1, 10.0)
+        P_work = d_step[:, None] * P_work * d_step[None, :]
+        A_work = e_step[:, None] * A_work * d_step[None, :]
+        q_work = d_step * q_work
+        D = D * d_step
+        E = E * e_step
+    one = torch.ones((), device=P.device, dtype=P.dtype)
+    norm = torch.maximum(
+        torch.amax(torch.abs(P_work)),
+        torch.linalg.vector_norm(q_work, ord=float("inf")),
+    )
+    cost = one / torch.maximum(norm, one)
+    scaling = {"D": D, "E": E, "cost": cost, "passes": passes}
+    workspace.scaling = scaling
+    workspace.scaling_source_p = P.detach().clone()
+    workspace.scaling_source_a = A.detach().clone()
+    workspace.scaling_passes = passes
+    return scaling
+
+
+def _scale_problem(P, q, A, l, u, scaling):
+    D, E, cost = scaling["D"], scaling["E"], scaling["cost"]
+    return (
+        cost * (D[:, None] * P * D[None, :]),
+        cost * D * q,
+        E[:, None] * A * D[None, :],
+        E * l,
+        E * u,
+    )
+
+
+def _initial_scaled_state(workspace, n, m, device, dtype, scaling, warm_start):
+    x_o = torch.zeros(n, device=device, dtype=dtype)
+    z_o = torch.zeros(m, device=device, dtype=dtype)
+    y_o = torch.zeros(m, device=device, dtype=dtype)
+    if warm_start and isinstance(workspace.state, dict):
+        x_o = _state_vector(workspace.state.get("x"), x_o)
+        z_o = _state_vector(workspace.state.get("z"), z_o)
+        y_o = _state_vector(workspace.state.get("y"), y_o)
+    D, E, cost = scaling["D"], scaling["E"], scaling["cost"]
+    return x_o / D, z_o * E, y_o * cost / E
+
+
+def _state_vector(value, fallback):
+    if not torch.is_tensor(value):
+        return fallback
+    value = value.detach().to(device=fallback.device, dtype=fallback.dtype).reshape(-1)
+    if value.numel() != fallback.numel() or not bool(torch.all(torch.isfinite(value)).item()):
+        return fallback
+    return value.clone()
+
+
+def _unscale_state(x, z, y, scaling):
+    D, E, cost = scaling["D"], scaling["E"], scaling["cost"]
+    return D * x, z / E, E * y / cost
+
+
+def _equality_mask(l, u):
+    finite = torch.isfinite(l) & torch.isfinite(u)
+    atol = 100.0 * torch.finfo(l.dtype).eps
+    return finite & torch.isclose(l, u, rtol=atol, atol=atol)
+
+
+def _rho_vector(rho_bar, equality):
+    rho_vec = torch.full(
+        equality.shape,
+        float(rho_bar.item()),
+        device=rho_bar.device,
+        dtype=rho_bar.dtype,
+    )
+    rho_vec[equality] *= 1000.0
+    return rho_vec
+
+
+def _adaptive_rho_update(rho_bar, equality, primal, dual, eps_primal, eps_dual, tolerance):
+    tiny = torch.as_tensor(
+        torch.finfo(rho_bar.dtype).tiny,
+        device=rho_bar.device,
+        dtype=rho_bar.dtype,
+    )
+    ratio = (primal / eps_primal.clamp_min(tiny)) / (
+        dual / eps_dual.clamp_min(tiny)
+    ).clamp_min(tiny)
+    if not bool(((ratio > tolerance) | (ratio < 1.0 / tolerance)).item()):
+        return False, rho_bar, _rho_vector(rho_bar, equality)
+    rho_bar = (rho_bar * torch.sqrt(ratio).clamp(0.1, 10.0)).clamp(1e-6, 1e6)
+    return True, rho_bar, _rho_vector(rho_bar, equality)
+
+
+def _residuals(P, q, A, x, z, y, eps_abs, eps_rel):
+    Ax, Px, ATy = A @ x, P @ x, A.T @ y
+    primal = torch.linalg.vector_norm(Ax - z, ord=float("inf"))
+    dual = torch.linalg.vector_norm(Px + q + ATy, ord=float("inf"))
+    eps_primal = eps_abs + eps_rel * torch.maximum(
+        torch.linalg.vector_norm(Ax, ord=float("inf")),
+        torch.linalg.vector_norm(z, ord=float("inf")),
+    )
+    eps_dual = eps_abs + eps_rel * torch.maximum(
+        torch.maximum(
+            torch.linalg.vector_norm(Px, ord=float("inf")),
+            torch.linalg.vector_norm(ATy, ord=float("inf")),
+        ),
+        torch.linalg.vector_norm(q, ord=float("inf")),
+    )
+    return primal, dual, eps_primal, eps_dual
+
+
+def _default_polish_info(settings):
+    enabled = bool(settings.get("polishing", True))
+    return {
+        "polishing": enabled,
+        "polishing_success": False,
+        "polishing_status": "not_run" if enabled else "disabled",
+        "polishing_time_ms": 0.0,
+        "polishing_active_constraints": 0,
+        "polishing_refine_iter": int(settings.get("polish_refine_iter", 3)),
+    }
+
+
+def _polish_solution(P, q, A, l, u, x, z, y, settings):
+    info = _default_polish_info(settings)
+    started = time.perf_counter()
+    equality = _equality_mask(l, u)
+    activity_tolerance = 10.0 * (
+        float(settings["eps_abs"])
+        + float(settings["eps_rel"])
+        * torch.maximum(torch.abs(z), torch.ones_like(z))
+    )
+    at_lower = torch.isfinite(l) & (torch.abs(z - l) <= activity_tolerance)
+    at_upper = torch.isfinite(u) & (torch.abs(z - u) <= activity_tolerance)
+    active = equality | ((y < 0) & at_lower) | ((y > 0) & at_upper)
+    equality_indices = torch.nonzero(equality & active, as_tuple=False).reshape(-1)
+    other_indices = torch.nonzero(active & ~equality, as_tuple=False).reshape(-1)
+    indices = torch.cat((equality_indices, other_indices))
+    info["polishing_active_constraints"] = int(indices.numel())
+    if indices.numel() == 0:
+        info["polishing_status"] = "skipped_no_active_constraints"
+        info["polishing_time_ms"] = (time.perf_counter() - started) * 1000
+        return x, z, y, info
+
+    A_active = A[indices]
+    rhs_active = torch.where(
+        equality[indices],
+        0.5 * (l[indices] + u[indices]),
+        torch.where(y[indices] < 0, l[indices], u[indices]),
+    )
+    indices, A_active, rhs_active = _drop_duplicate_active_rows(
+        indices, A_active, rhs_active
+    )
+    info["polishing_active_constraints"] = int(indices.numel())
+    delta = float(settings.get("polish_delta", 1e-6))
+    n, p = q.numel(), indices.numel()
+    K_exact = torch.cat(
+        (
+            torch.cat(
+                (P, A_active.T),
+                dim=1,
+            ),
+            torch.cat(
+                (
+                    A_active,
+                    torch.zeros((p, p), device=q.device, dtype=q.dtype),
+                ),
+                dim=1,
+            ),
+        ),
+        dim=0,
+    )
+    regularizer = torch.cat(
+        (
+            torch.cat(
+                (
+                    delta * torch.eye(n, device=q.device, dtype=q.dtype),
+                    torch.zeros((n, p), device=q.device, dtype=q.dtype),
+                ),
+                dim=1,
+            ),
+            torch.cat(
+                (
+                    torch.zeros((p, n), device=q.device, dtype=q.dtype),
+                    -delta * torch.eye(p, device=q.device, dtype=q.dtype),
+                ),
+                dim=1,
+            ),
+        ),
+        dim=0,
+    )
+    K_regularized = K_exact + regularizer
+    rhs = torch.cat((-q, rhs_active))
+    polish_solver = DenseLUSolver()
+    try:
+        try:
+            polish_solver.factorize(K_exact)
+            polished, _ = polish_solver.solve(
+                rhs,
+                calculate_residual=bool(
+                    settings.get("check_linear_residual", False)
+                ),
+            )
+            info["polishing_regularized"] = False
+        except TorchLinearSolveError:
+            polish_solver.factorize(K_regularized)
+            polished, _ = polish_solver.solve(
+                rhs,
+                calculate_residual=bool(
+                    settings.get("check_linear_residual", False)
+                ),
+            )
+            for _ in range(int(settings.get("polish_refine_iter", 3))):
+                correction, _ = polish_solver.solve(rhs - K_exact @ polished)
+                polished = polished + correction
+            info["polishing_regularized"] = True
+    except (ValueError, TorchLinearSolveError) as exc:
+        raise TorchLinearSolveError(f"Requested polishing failed: {exc}") from exc
+
+    x_candidate = polished[:n]
+    y_candidate = torch.zeros_like(y)
+    y_candidate[indices] = polished[n:]
+    z_candidate = torch.maximum(torch.minimum(A @ x_candidate, u), l)
+    old = _residuals(
+        P, q, A, x, z, y, float(settings["eps_abs"]), float(settings["eps_rel"])
+    )
+    new = _residuals(
+        P,
+        q,
+        A,
+        x_candidate,
+        z_candidate,
+        y_candidate,
+        float(settings["eps_abs"]),
+        float(settings["eps_rel"]),
+    )
+    tiny = torch.as_tensor(torch.finfo(q.dtype).tiny, device=q.device, dtype=q.dtype)
+    old_score = torch.maximum(old[0] / old[2].clamp_min(tiny), old[1] / old[3].clamp_min(tiny))
+    new_score = torch.maximum(new[0] / new[2].clamp_min(tiny), new[1] / new[3].clamp_min(tiny))
+    satisfies = bool(((new[0] <= new[2]) & (new[1] <= new[3])).item())
+    if not satisfies and not bool((new_score <= old_score).item()):
+        info.update(
+            {
+                "polishing_status": "rejected_no_improvement",
+                "polishing_old_score": float(old_score.item()),
+                "polishing_new_score": float(new_score.item()),
+                "polishing_time_ms": (time.perf_counter() - started) * 1000,
+            }
+        )
+        return x, z, y, info
+    info.update(
+        {
+            "polishing_success": True,
+            "polishing_status": "accepted",
+            "polishing_old_score": float(old_score.item()),
+            "polishing_new_score": float(new_score.item()),
+            "polishing_time_ms": (time.perf_counter() - started) * 1000,
+        }
+    )
+    return x_candidate, z_candidate, y_candidate, info
+
+
+def _drop_duplicate_active_rows(indices, rows, rhs):
+    """Keep equality-first representatives of identical active constraints."""
+
+    if indices.numel() <= 1:
+        return indices, rows, rhs
+    augmented = torch.cat((rows, rhs[:, None]), dim=1)
+    _, inverse = torch.unique(augmented, dim=0, return_inverse=True)
+    positions = torch.arange(rows.shape[0], device=rows.device, dtype=torch.long)
+    first = torch.full(
+        (int(torch.max(inverse).item()) + 1,),
+        rows.shape[0],
+        device=rows.device,
+        dtype=torch.long,
+    )
+    first.scatter_reduce_(0, inverse, positions, reduce="amin", include_self=True)
+    keep_tensor = torch.sort(first).values
+    return indices[keep_tensor], rows[keep_tensor], rhs[keep_tensor]
diff --git a/pygranso/pygransoOptions.py b/pygranso/pygransoOptions.py
index d7fefa0..700814a 100644
--- a/pygranso/pygransoOptions.py
+++ b/pygranso/pygransoOptions.py
@@ -330,9 +330,28 @@ def pygransoOptions(n, options):
 
         Select the QP solver used in the steering strategy and termination condition. Currently only OSQP is supported.
 
+        osqp_algebra
+        --------------------------------
+        String in {'auto','builtin','torch'}. Default value: 'auto'
+
+        Selects the OSQP algebra policy for PyGRANSO's QP subproblems.
+        The 'auto' policy follows torch_device: CPU uses builtin OSQP and a
+        validated accelerator uses the dense Torch reference route inside its
+        supported KKT and memory envelope. Unsupported or unsuccessful Torch
+        solves fall back to builtin OSQP with a warning and diagnostics.
+        The Torch route exposes no nested linear-solver selector.
+        Builtin workspaces and structurally compatible warm starts are reused
+        automatically within one BFGS-SQP run.
+
+        osqp_settings
+        --------------------------------
+        Dict of common builtin/Torch OSQP settings. The adapter supplies
+        dtype-aware defaults (1e-8 for float64 and 1e-5 for float32), Ruiz
+        scaling, adaptive rho, polishing, and warm starts.
+
         torch_device
         --------------------------------
-        torch.device('cpu') OR torch.device('cuda'). Default value: torch.device('cpu')
+        A supported torch.device. Default value: torch.device('cpu')
 
         Choose torch.device used for matrix operation in PyGRANSO.
         opts.torch_device = torch.device('cuda') if one wants to use cuda device
@@ -532,6 +551,17 @@ def pygransoOptions(n, options):
         validator.setRealInIntervalOO("steering_c_mu", 0, 1)
         validator.setLogical("quadprog_info_msg")
         validator.setString("QPsolver")
+        validator.setString("osqp_algebra")
+        validator.validateAndSet(
+            "osqp_algebra",
+            lambda x: x in {"auto", "builtin", "torch"},
+            "one of {'auto','builtin','torch'}",
+        )
+        validator.validateAndSet(
+            "osqp_settings",
+            lambda x: isinstance(x, dict),
+            "a dict of OSQP settings",
+        )
         validator.setRealInIntervalCC("regularize_threshold", 1, np.inf)
         validator.setLogical("regularize_max_eigenvalues")
         validator.setLogical("stat_l2_model")
@@ -655,6 +685,12 @@ def getDefaults(n):
     setattr(default_opts, "regularize_max_eigenvalues", False)
     setattr(default_opts, "quadprog_info_msg", True)
     setattr(default_opts, "QPsolver", "osqp")
+    setattr(default_opts, "osqp_algebra", "auto")
+    setattr(
+        default_opts,
+        "osqp_settings",
+        {},
+    )
     setattr(default_opts, "wolfe1", 1e-4)
     setattr(default_opts, "wolfe2", 0.5)
     setattr(default_opts, "linesearch_nondescent_maxit", 0)
diff --git a/pyproject.toml b/pyproject.toml
index 7c3dfc0..aa51de9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@ name = "pygranso"
 version = "2.0.0"
 description = "PyGRANSO: A PyTorch-enabled port of GRANSO with auto-differentiation"
 readme = "README.md"
-requires-python = ">=3.13.7"
+requires-python = ">=3.10"
 dependencies = [
     "click>=8.2.1",
     "e3nn>=0.5.7",
@@ -36,10 +36,18 @@ ignore = [
     "E741",   # ambiguous variable name l, O (legacy)
     "F811",   # redefinition (e.g. copyrightNotice import + use)
     "UP031",  # percent format (legacy; can migrate later)
-    "UP038",  # X | Y isinstance (Python 3.10+)
 ]
 isort = { known-first-party = ["pygranso"] }
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "nightly: deterministic randomized or numerical-stress coverage",
+    "cuda: requires a real CUDA device",
+    "rocm: requires a real ROCm device",
+    "mps: requires a real Apple MPS device",
+]
+
 [tool.ruff.lint.per-file-ignores]
 "test_cpu.py" = ["F841"]
 "test_cuda.py" = ["F841"]
diff --git a/research_archive/README.md b/research_archive/README.md
new file mode 100644
index 0000000..3b15a98
--- /dev/null
+++ b/research_archive/README.md
@@ -0,0 +1,34 @@
+# Sparse-CG and CUDA Graph Research Snapshot
+
+This directory documents the final research snapshot preserved on
+`archive/sparse-cg-cuda-graph` and tagged as
+`research-sparse-cg-cuda-graph-final` before the production package moves to
+the dense Torch reference architecture.
+
+## Preserved scope
+
+- Sparse Torch OSQP operators and conjugate-gradient solves.
+- Jacobi preconditioning and reduced-system matrix-vector products.
+- CUDA Graph capture and replay experiments.
+- Adaptive rho, Ruiz scaling, polishing, and warm-state experiments.
+- Runtime and end-to-end PyGRANSO benchmark drivers.
+- OSQP adapter tests, presentation material, and supporting documentation.
+
+## Baseline validation
+
+Validated on 2026-06-23 (America/Chicago) with Python 3.12 and PyTorch
+2.11.0+cu128:
+
+```text
+python -m pytest test_osqp_torch_adapter.py -q -p no:cacheprovider
+79 passed, 10 warnings in 40.37s
+```
+
+The warnings were limited to PyTorch sparse beta/invariant notices and OSQP
+deprecation notices. No test failed.
+
+## Archive policy
+
+This snapshot is research history, not the supported production solver path.
+Future experiments should branch from the archive reference rather than add
+custom numerical linear-solver code back to the normal package path.
diff --git a/scripts/render_pipeline_pdf.py b/scripts/render_pipeline_pdf.py
new file mode 100644
index 0000000..8c3f4e1
--- /dev/null
+++ b/scripts/render_pipeline_pdf.py
@@ -0,0 +1,233 @@
+"""Render the maintained Torch-OSQP pipeline Markdown as a polished PDF."""
+
+from __future__ import annotations
+
+import re
+from html import escape
+from pathlib import Path
+
+from reportlab.lib import colors
+from reportlab.lib.enums import TA_CENTER
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib.units import inch
+from reportlab.platypus import (
+    BaseDocTemplate,
+    Frame,
+    KeepTogether,
+    ListFlowable,
+    ListItem,
+    PageBreak,
+    PageTemplate,
+    Paragraph,
+    Preformatted,
+    Spacer,
+    Table,
+    TableStyle,
+)
+from reportlab.platypus.tableofcontents import TableOfContents
+
+ROOT = Path(__file__).resolve().parents[1]
+SOURCE = ROOT / "docs" / "FULL_DEVELOPMENT_AND_VALIDATION_PIPELINE.md"
+OUTPUT = ROOT / "output" / "pdf" / "Full Development and Validation Pipeline - Revised.pdf"
+
+
+class PipelineDocument(BaseDocTemplate):
+    def __init__(self, filename, **kwargs):
+        super().__init__(filename, **kwargs)
+        frame = Frame(self.leftMargin, self.bottomMargin, self.width, self.height, id="body")
+        self.addPageTemplates(PageTemplate(id="main", frames=frame, onPage=draw_page))
+
+    def afterFlowable(self, flowable):
+        if not isinstance(flowable, Paragraph):
+            return
+        style = flowable.style.name
+        match = re.fullmatch(r"Heading([1-3])Custom", style)
+        if match:
+            level = int(match.group(1)) - 1
+            text = flowable.getPlainText()
+            key = f"heading-{self.page}-{len(text)}-{level}"
+            self.canv.bookmarkPage(key)
+            self.canv.addOutlineEntry(text, key, level=level, closed=False)
+            self.notify("TOCEntry", (level, text, self.page, key))
+
+
+def draw_page(canvas, document):
+    canvas.saveState()
+    canvas.setStrokeColor(colors.HexColor("#D7DEE8"))
+    canvas.line(document.leftMargin, 0.58 * inch, letter[0] - document.rightMargin, 0.58 * inch)
+    canvas.setFillColor(colors.HexColor("#536273"))
+    canvas.setFont("Helvetica", 8)
+    canvas.drawString(document.leftMargin, 0.38 * inch, "Torch-OSQP Development and Validation Pipeline")
+    canvas.drawRightString(letter[0] - document.rightMargin, 0.38 * inch, str(document.page))
+    canvas.restoreState()
+
+
+def styles():
+    sheet = getSampleStyleSheet()
+    navy = colors.HexColor("#173A5E")
+    blue = colors.HexColor("#246B9E")
+    sheet.add(ParagraphStyle(name="TitleCustom", parent=sheet["Title"], fontName="Helvetica-Bold", fontSize=25, leading=30, textColor=navy, alignment=TA_CENTER, spaceAfter=18))
+    sheet.add(ParagraphStyle(name="Subtitle", parent=sheet["Normal"], fontSize=11, leading=16, textColor=colors.HexColor("#536273"), alignment=TA_CENTER, spaceAfter=8))
+    sheet.add(ParagraphStyle(name="TOCTitle", parent=sheet["Heading2"], fontName="Helvetica-Bold", fontSize=15, leading=19, textColor=blue, spaceBefore=18, spaceAfter=8))
+    for level, size, before, after in ((1, 19, 18, 10), (2, 15, 15, 8), (3, 12, 12, 6)):
+        sheet.add(ParagraphStyle(name=f"Heading{level}Custom", parent=sheet[f"Heading{level}"], fontName="Helvetica-Bold", fontSize=size, leading=size + 4, textColor=navy if level == 1 else blue, spaceBefore=before, spaceAfter=after, keepWithNext=True))
+    sheet.add(ParagraphStyle(name="Subheading", parent=sheet["Heading4"], fontName="Helvetica-Bold", fontSize=10, leading=13, textColor=blue, spaceBefore=8, spaceAfter=4, keepWithNext=True))
+    sheet.add(ParagraphStyle(name="BodyCustom", parent=sheet["BodyText"], fontSize=9.4, leading=13.2, textColor=colors.HexColor("#25313D"), spaceAfter=6))
+    sheet.add(ParagraphStyle(name="TableHeaderCustom", parent=sheet["BodyText"], fontName="Helvetica-Bold", fontSize=9.0, leading=12.5, textColor=colors.white, spaceAfter=0))
+    sheet.add(ParagraphStyle(name="BulletCustom", parent=sheet["BodyText"], fontSize=9.2, leading=12.8, leftIndent=4, textColor=colors.HexColor("#25313D")))
+    sheet.add(ParagraphStyle(name="CodeCustom", fontName="Courier", fontSize=7.6, leading=10, leftIndent=8, rightIndent=8, borderColor=colors.HexColor("#C8D3DF"), borderWidth=0.6, borderPadding=8, backColor=colors.HexColor("#F4F7FA"), spaceBefore=4, spaceAfter=8))
+    return sheet
+
+
+def inline_markup(text):
+    text = escape(text.strip())
+    text = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", text)
+    text = re.sub(r"`([^`]+)`", r'<font name="Courier">\1</font>', text)
+    return text
+
+
+def parse_table(lines, sheet):
+    rows = [[inline_markup(cell) for cell in line.strip().strip("|").split("|")] for line in lines]
+    rows = [rows[0]] + rows[2:]
+    data = [
+        [
+            Paragraph(
+                cell,
+                sheet["TableHeaderCustom"] if row_index == 0 else sheet["BodyCustom"],
+            )
+            for cell in row
+        ]
+        for row_index, row in enumerate(rows)
+    ]
+    table = Table(data, repeatRows=1, hAlign="LEFT", colWidths=[None] * len(data[0]))
+    table.setStyle(TableStyle([
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#173A5E")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+        ("GRID", (0, 0), (-1, -1), 0.35, colors.HexColor("#C8D3DF")),
+        ("BACKGROUND", (0, 1), (-1, -1), colors.white),
+        ("VALIGN", (0, 0), (-1, -1), "TOP"),
+        ("LEFTPADDING", (0, 0), (-1, -1), 6),
+        ("RIGHTPADDING", (0, 0), (-1, -1), 6),
+        ("TOPPADDING", (0, 0), (-1, -1), 5),
+        ("BOTTOMPADDING", (0, 0), (-1, -1), 5),
+    ]))
+    return table
+
+
+def markdown_story(text):
+    sheet = styles()
+    story = []
+    lines = text.splitlines()
+    index = 0
+    first_heading = True
+    while index < len(lines):
+        line = lines[index]
+        if line.strip() == "<!-- PAGEBREAK -->":
+            story.append(PageBreak())
+            index += 1
+            continue
+        if line.startswith("```"):
+            code = []
+            index += 1
+            while index < len(lines) and not lines[index].startswith("```"):
+                code.append(lines[index])
+                index += 1
+            story.append(KeepTogether(Preformatted("\n".join(code), sheet["CodeCustom"])))
+            index += 1
+            continue
+        if line.startswith("|") and index + 1 < len(lines) and lines[index + 1].startswith("|"):
+            table_lines = []
+            while index < len(lines) and lines[index].startswith("|"):
+                table_lines.append(lines[index])
+                index += 1
+            story.append(parse_table(table_lines, sheet))
+            story.append(Spacer(1, 8))
+            continue
+        heading = re.match(r"^(#{1,4})\s+(.+)$", line)
+        if heading:
+            level = len(heading.group(1))
+            title = heading.group(2)
+            if first_heading:
+                story.append(Spacer(1, 1.05 * inch))
+                story.append(Paragraph(inline_markup(title), sheet["TitleCustom"]))
+                first_heading = False
+            else:
+                if level == 4:
+                    story.append(Paragraph(inline_markup(title), sheet["Subheading"]))
+                    index += 1
+                    continue
+                if title == "Part I - Executive Summary":
+                    toc = TableOfContents()
+                    toc.levelStyles = [
+                        ParagraphStyle(name="TOC1", fontSize=9, leading=13, leftIndent=0, textColor=colors.HexColor("#173A5E")),
+                        ParagraphStyle(name="TOC2", fontSize=8.5, leading=12, leftIndent=14, textColor=colors.HexColor("#536273")),
+                        ParagraphStyle(name="TOC3", fontSize=8, leading=11, leftIndent=28, textColor=colors.HexColor("#536273")),
+                    ]
+                    story.extend(
+                        [
+                            Paragraph("Table of Contents", sheet["TOCTitle"]),
+                            toc,
+                            PageBreak(),
+                            Paragraph(inline_markup(title), sheet["Heading1Custom"]),
+                        ]
+                    )
+                else:
+                    document_level = max(1, level - 1)
+                    story.append(
+                        Paragraph(
+                            inline_markup(title),
+                            sheet[f"Heading{document_level}Custom"],
+                        )
+                    )
+            index += 1
+            continue
+        if line.startswith("- "):
+            items = []
+            while index < len(lines) and lines[index].startswith("- "):
+                items.append(ListItem(Paragraph(inline_markup(lines[index][2:]), sheet["BulletCustom"]), leftIndent=12))
+                index += 1
+            story.append(ListFlowable(items, bulletType="bullet", leftIndent=18, bulletFontSize=6, spaceAfter=6))
+            continue
+        if re.match(r"^\d+\.\s", line):
+            items = []
+            while index < len(lines) and re.match(r"^\d+\.\s", lines[index]):
+                content = re.sub(r"^\d+\.\s", "", lines[index])
+                items.append(ListItem(Paragraph(inline_markup(content), sheet["BulletCustom"]), leftIndent=14))
+                index += 1
+            story.append(ListFlowable(items, bulletType="1", leftIndent=20, spaceAfter=6))
+            continue
+        if not line.strip():
+            index += 1
+            continue
+        paragraph = [line.strip()]
+        index += 1
+        while index < len(lines) and lines[index].strip() and not re.match(r"^(#{1,4})\s|^-\s|^\d+\.\s|^```|^\||^<!--", lines[index]):
+            paragraph.append(lines[index].strip())
+            index += 1
+        text_value = " ".join(paragraph)
+        style = sheet["Subtitle"] if text_value.startswith(("Version:", "Date:", "Status:")) else sheet["BodyCustom"]
+        story.append(KeepTogether([Paragraph(inline_markup(text_value), style)]))
+    return story
+
+
+def main():
+    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+    document = PipelineDocument(
+        str(OUTPUT),
+        pagesize=letter,
+        leftMargin=0.68 * inch,
+        rightMargin=0.68 * inch,
+        topMargin=0.62 * inch,
+        bottomMargin=0.72 * inch,
+        title="Full Development and Validation Pipeline",
+        author="PyGRANSO Research Team",
+    )
+    story = markdown_story(SOURCE.read_text(encoding="utf-8"))
+    document.multiBuild(story)
+    print(OUTPUT)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..8f3afb9
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,20 @@
+import os
+
+import pytest
+import torch
+
+
+def pytest_generate_tests(metafunc):
+    if "random_seed" in metafunc.fixturenames:
+        count = 100 if os.getenv("PYGRANSO_NIGHTLY") == "1" else 10
+        metafunc.parametrize("random_seed", range(count))
+
+
+@pytest.fixture(params=[torch.float32, torch.float64])
+def floating_dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=["cpu"] + (["cuda"] if torch.cuda.is_available() else []))
+def available_device(request):
+    return torch.device(request.param)
diff --git a/tests/test_osqp_backend_agreement.py b/tests/test_osqp_backend_agreement.py
new file mode 100644
index 0000000..0dbbdbc
--- /dev/null
+++ b/tests/test_osqp_backend_agreement.py
@@ -0,0 +1,46 @@
+import pytest
+import torch
+
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def _solve(H, f, A, b, lower, upper, algebra):
+    settings = {
+        "return_info": True,
+        "eps_abs": 1e-8,
+        "eps_rel": 1e-8,
+        "scaling": 10,
+        "adaptive_rho": True,
+        "polishing": True,
+    }
+    return solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        lower,
+        upper,
+        torch.device("cpu"),
+        True,
+        {"algebra": algebra, "settings": settings},
+        TorchOSQPWorkspace(),
+    )
+
+
+@pytest.mark.parametrize("with_equality", [False, True])
+def test_builtin_and_torch_agree_on_observable_outcomes(with_equality):
+    dtype = torch.float64
+    H = torch.tensor([[4.0, 1.0], [1.0, 2.0]], dtype=dtype)
+    f = torch.tensor([[-1.0], [-1.0]], dtype=dtype)
+    lower = torch.zeros((2, 1), dtype=dtype)
+    upper = torch.ones((2, 1), dtype=dtype)
+    A = torch.tensor([[1.0, 1.0]], dtype=dtype) if with_equality else None
+    b = torch.tensor(0.75, dtype=dtype) if with_equality else None
+    torch_solution, torch_info = _solve(H, f, A, b, lower, upper, "torch")
+    builtin_solution, builtin_info = _solve(H, f, A, b, lower, upper, "builtin")
+    assert torch_info["status_compatible"]
+    assert builtin_info["status_compatible"]
+    assert torch.allclose(torch_solution, builtin_solution, atol=2e-6, rtol=2e-6)
+    objective_scale = max(1.0, abs(builtin_info["objective"]))
+    assert abs(torch_info["objective"] - builtin_info["objective"]) / objective_scale < 1e-7
diff --git a/tests/test_osqp_workspace_lifecycle.py b/tests/test_osqp_workspace_lifecycle.py
new file mode 100644
index 0000000..8e08556
--- /dev/null
+++ b/tests/test_osqp_workspace_lifecycle.py
@@ -0,0 +1,108 @@
+import torch
+
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+from pygranso.private.torchOSQP import _prepare_workspace
+
+
+def _seed_workspace(workspace):
+    workspace.state = {
+        "x": torch.ones(2),
+        "z": torch.ones(2),
+        "y": torch.ones(2),
+    }
+    workspace.rho_bar = 0.25
+    workspace.rho_setting = 0.1
+
+
+def test_compatible_matrix_value_update_preserves_warm_state():
+    workspace = TorchOSQPWorkspace()
+    P = torch.eye(2, dtype=torch.float64)
+    A = torch.eye(2, dtype=torch.float64)
+    _prepare_workspace(workspace, P, A, ("bounds", 2))
+    _seed_workspace(workspace)
+    _prepare_workspace(workspace, 2.0 * P, 3.0 * A, ("bounds", 2))
+    assert workspace.state is not None
+    assert workspace.rho_bar == 0.25
+
+
+def test_structure_change_invalidates_complete_torch_state():
+    workspace = TorchOSQPWorkspace()
+    P = torch.eye(2, dtype=torch.float64)
+    A = torch.eye(2, dtype=torch.float64)
+    _prepare_workspace(workspace, P, A, ("bounds", 2))
+    _seed_workspace(workspace)
+    changed = A.clone()
+    changed[0, 1] = 1.0
+    _prepare_workspace(workspace, P, changed, ("bounds", 2))
+    assert workspace.state is None
+    assert workspace.rho_bar is None
+    assert not workspace.linear_solver.ready
+
+
+def test_constraint_order_signature_change_invalidates_complete_torch_state():
+    workspace = TorchOSQPWorkspace()
+    P = torch.eye(2, dtype=torch.float64)
+    A = torch.ones((2, 2), dtype=torch.float64)
+    _prepare_workspace(workspace, P, A, ("c1", "c2"))
+    _seed_workspace(workspace)
+    _prepare_workspace(workspace, P, A, ("c2", "c1"))
+    assert workspace.state is None
+    assert workspace.constraint_order_signature == ("c2", "c1")
+
+
+def test_dimension_and_dtype_changes_invalidate_complete_torch_state():
+    for changed_p, changed_a in (
+        (torch.eye(3, dtype=torch.float64), torch.eye(3, dtype=torch.float64)),
+        (torch.eye(2, dtype=torch.float32), torch.eye(2, dtype=torch.float32)),
+    ):
+        workspace = TorchOSQPWorkspace()
+        _prepare_workspace(
+            workspace,
+            torch.eye(2, dtype=torch.float64),
+            torch.eye(2, dtype=torch.float64),
+            ("bounds", 2),
+        )
+        _seed_workspace(workspace)
+        _prepare_workspace(workspace, changed_p, changed_a, ("changed",))
+        assert workspace.state is None
+        assert workspace.rho_bar is None
+
+
+def test_a_value_update_preserves_state_but_forces_new_factors():
+    from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+
+    dtype = torch.float64
+    workspace = TorchOSQPWorkspace()
+    H = torch.eye(2, dtype=dtype)
+    f = torch.zeros((2, 1), dtype=dtype)
+    lower = -torch.ones((2, 1), dtype=dtype)
+    upper = torch.ones((2, 1), dtype=dtype)
+    settings = {"return_info": True, "polishing": False}
+    _, first = solve_osqp_torch_qp(
+        H,
+        f,
+        torch.tensor([[1.0, 1.0]], dtype=dtype),
+        torch.tensor(0.0, dtype=dtype),
+        lower,
+        upper,
+        "cpu",
+        True,
+        {"algebra": "torch", "settings": settings},
+        workspace,
+    )
+    prior_state = {key: value.clone() for key, value in workspace.state.items()}
+    _, second = solve_osqp_torch_qp(
+        H,
+        f,
+        torch.tensor([[2.0, 1.0]], dtype=dtype),
+        torch.tensor(0.0, dtype=dtype),
+        lower,
+        upper,
+        "cpu",
+        True,
+        {"algebra": "torch", "settings": settings},
+        workspace,
+    )
+    assert first["factorizations_this_solve"] >= 1
+    assert second["factorizations_this_solve"] >= 1
+    assert prior_state.keys() == workspace.state.keys()
diff --git a/tests/test_pygranso_osqp_end_to_end.py b/tests/test_pygranso_osqp_end_to_end.py
new file mode 100644
index 0000000..73856f2
--- /dev/null
+++ b/tests/test_pygranso_osqp_end_to_end.py
@@ -0,0 +1,54 @@
+from argparse import Namespace
+
+import pytest
+
+from bench_pygranso_osqp_workloads import make_workload, summarize_trace
+from pygranso.private.solveQP import beginOSQPTrace, endOSQPTrace
+from pygranso.pygranso import pygranso
+
+
+def _run(name, algebra, *, capture_trace=False):
+    args = Namespace(
+        seed=0,
+        maxit=1,
+        eps_abs=1e-8,
+        eps_rel=1e-8,
+        qp_max_iter=4000,
+    )
+    method = "cpu_warm" if algebra == "builtin" else "torch_cuda"
+    var_spec, combined_fn, opts = make_workload(
+        name, "cpu", args.seed, args.maxit, method, args
+    )
+    opts.osqp_algebra = algebra
+    if capture_trace:
+        beginOSQPTrace(capture_data=True)
+    try:
+        solution = pygranso(
+            var_spec=var_spec,
+            combined_fn=combined_fn,
+            user_opts=opts,
+        )
+    finally:
+        trace = endOSQPTrace() if capture_trace else None
+    metrics = {
+        "termination_code": int(solution.termination_code),
+        "objective": float(solution.final.f),
+        "feasibility": float(solution.final.tv),
+        "stationarity": float(solution.stat_value),
+    }
+    return metrics, trace
+
+
+@pytest.mark.parametrize("workload", ["B1", "B2", "B3"])
+def test_b1_b2_b3_complete_runs_agree_on_optimizer_observables(workload):
+    builtin, trace = _run(workload, "builtin", capture_trace=True)
+    torch_result, _ = _run(workload, "torch")
+    assert torch_result["termination_code"] == builtin["termination_code"]
+    for key in ("objective", "feasibility", "stationarity"):
+        scale = max(1.0, abs(builtin[key]))
+        assert abs(torch_result[key] - builtin[key]) / scale <= 1e-7
+
+    summary = summarize_trace(trace)
+    assert summary["qp_count"] >= 1
+    assert summary["qp_matrix_value_changes"] >= 0
+    assert summary["qp_shapes"]
diff --git a/tests/test_pygranso_qp_failure_contracts.py b/tests/test_pygranso_qp_failure_contracts.py
new file mode 100644
index 0000000..f6d1196
--- /dev/null
+++ b/tests/test_pygranso_qp_failure_contracts.py
@@ -0,0 +1,46 @@
+import importlib
+
+import pytest
+import torch
+
+from pygranso.private.qpSteeringStrategy import qpSS
+from pygranso.private.qpTerminationCondition import qpTC
+
+
+def test_stationarity_qp_exhaustion_returns_outer_fallback_sentinel():
+    termination = qpTC()
+    termination.H = torch.eye(2, dtype=torch.float64)
+    termination.all_grads = torch.eye(2, dtype=torch.float64)
+
+    def fail(_matrix):
+        raise RuntimeError("synthetic stationarity QP failure")
+
+    termination.solveQP_fn = fail
+    x, lambdas, stat_type, errors = termination.solveQPRobust(torch.float64)
+    assert x is None
+    assert lambdas is None
+    assert stat_type == 0
+    assert len(errors) == 3
+    assert all("synthetic" in str(error) for error in errors)
+
+
+def test_steering_qp_preserves_original_failure(monkeypatch):
+    steering_module = importlib.import_module(
+        "pygranso.private.qpSteeringStrategy"
+    )
+    steering = qpSS()
+    steering.QPsolver = "osqp"
+    steering.H = torch.eye(1, dtype=torch.float64)
+    steering.f = torch.zeros((1, 1), dtype=torch.float64)
+    steering.LB = -torch.ones((1, 1), dtype=torch.float64)
+    steering.UB = torch.ones((1, 1), dtype=torch.float64)
+    steering.device = torch.device("cpu")
+    steering.double_precision = True
+    steering.osqp_options = {}
+
+    def fail(*args, **kwargs):
+        raise RuntimeError("synthetic steering QP failure")
+
+    monkeypatch.setattr(steering_module, "solveQP", fail)
+    with pytest.raises(RuntimeError, match="synthetic steering QP failure"):
+        steering.solveSteeringDualQP()
diff --git a/tests/test_stability_reporting.py b/tests/test_stability_reporting.py
new file mode 100644
index 0000000..c10aef2
--- /dev/null
+++ b/tests/test_stability_reporting.py
@@ -0,0 +1,104 @@
+import csv
+import json
+from argparse import Namespace
+
+import pytest
+import torch
+
+import torch_osqp_stability as stability
+from torch_osqp_stability import (
+    CSV_COLUMNS,
+    environment_manifest,
+    source_tree_fingerprint,
+)
+
+
+def test_source_tree_fingerprint_is_deterministic_and_nonempty():
+    first = source_tree_fingerprint()
+    second = source_tree_fingerprint()
+    assert first == second
+    digest, file_count = first
+    assert len(digest) == 64
+    assert file_count > 20
+
+
+def test_manifest_records_exact_source_provenance():
+    args = Namespace(
+        device="cpu",
+        dtype="float64",
+        seeds=1,
+        stress_seeds=0,
+        time_limit_seconds=7200.0,
+    )
+    manifest = environment_manifest(args)
+    assert len(manifest["source_tree_sha256"]) == 64
+    assert manifest["source_file_count"] > 20
+    assert isinstance(manifest["git_status_entries"], (list, type(None)))
+
+
+def test_time_limit_exit_writes_partial_artifacts(tmp_path, monkeypatch):
+    def fake_evaluate(family, seed, device, dtype):
+        row = {column: None for column in CSV_COLUMNS}
+        row.update(
+            {
+                "test_family": family,
+                "case_name": f"{family}_seed_{seed}",
+                "seed": seed,
+                "device": str(device),
+                "dtype": str(dtype),
+                "overall_status": "passed",
+                "release_gate": "passed",
+                "failure_reason": "",
+            }
+        )
+        problem = (
+            torch.eye(1, dtype=dtype, device=device),
+            torch.zeros((1, 1), dtype=dtype, device=device),
+            None,
+            None,
+            torch.zeros((1, 1), dtype=dtype, device=device),
+            torch.ones((1, 1), dtype=dtype, device=device),
+        )
+        return row, problem
+
+    ticks = iter([0.0, 0.2, 0.4])
+    monkeypatch.setattr(stability, "evaluate", fake_evaluate)
+    monkeypatch.setattr(stability.time, "perf_counter", lambda: next(ticks))
+
+    args = Namespace(
+        output=str(tmp_path),
+        device="cpu",
+        dtype="float64",
+        seeds=1,
+        stress_seeds=1,
+        time_limit_seconds=0.1,
+    )
+    with pytest.raises(SystemExit, match="1/3 cases"):
+        stability.run(args)
+
+    with (tmp_path / "torch_osqp_stability_results.csv").open(
+        newline="", encoding="utf-8"
+    ) as handle:
+        rows = list(csv.DictReader(handle))
+    manifest = json.loads(
+        (tmp_path / "torch_osqp_stability_manifest.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    summary = (tmp_path / "torch_osqp_stability_summary.md").read_text(
+        encoding="utf-8"
+    )
+
+    assert len(rows) == 1
+    assert rows[0]["case_name"] == "randomized_bounds_seed_0"
+    assert manifest["timed_out"] is True
+    assert manifest["partial_results"] is True
+    assert manifest["completed_cases"] == 1
+    assert manifest["planned_cases"] == 3
+    assert manifest["timeout_after_case"] == {
+        "completed_cases": 1,
+        "test_family": "randomized_bounds",
+        "seed": 0,
+    }
+    assert "- Cases: 1/3" in summary
+    assert "- Timed out: True" in summary
diff --git a/tests/test_torch_linear_solve.py b/tests/test_torch_linear_solve.py
new file mode 100644
index 0000000..29a0c84
--- /dev/null
+++ b/tests/test_torch_linear_solve.py
@@ -0,0 +1,85 @@
+import pytest
+import torch
+
+from pygranso.private.torchLinearSolve import DenseLUSolver, TorchLinearSolveError
+
+
+def test_known_system_and_multiple_rhs(floating_dtype, available_device):
+    matrix = torch.tensor(
+        [[4.0, 1.0], [2.0, 3.0]],
+        device=available_device,
+        dtype=floating_dtype,
+    )
+    rhs = torch.tensor(
+        [[1.0, 2.0], [0.0, 1.0]],
+        device=available_device,
+        dtype=floating_dtype,
+    )
+    solver = DenseLUSolver()
+    solver.factorize(matrix)
+    solution, info = solver.solve(rhs, calculate_residual=True)
+    tolerance = 1e-5 if floating_dtype == torch.float32 else 1e-12
+    assert torch.allclose(matrix @ solution, rhs, rtol=tolerance, atol=tolerance)
+    assert info["relative_linear_residual"] <= tolerance
+
+
+def test_factorization_is_reused():
+    matrix = torch.eye(3, dtype=torch.float64)
+    solver = DenseLUSolver()
+    assert solver.factorize_if_needed(matrix)
+    assert not solver.factorize_if_needed(matrix.clone())
+    solver.solve(torch.ones(3, dtype=torch.float64))
+    assert solver.factorization_count == 1
+    assert solver.solve_count == 1
+
+
+def test_vector_rhs_is_normalized_internally_and_shape_is_restored():
+    matrix = torch.tensor([[3.0, 1.0], [1.0, 2.0]], dtype=torch.float64)
+    solver = DenseLUSolver()
+    solver.factorize(matrix)
+    vector_solution, _ = solver.solve(torch.ones(2, dtype=torch.float64))
+    column_solution, _ = solver.solve(torch.ones((2, 1), dtype=torch.float64))
+    assert vector_solution.shape == (2,)
+    assert column_solution.shape == (2, 1)
+    assert torch.allclose(vector_solution, column_solution.reshape(-1))
+
+
+@pytest.mark.parametrize(
+    "matrix,rhs,error",
+    [
+        (torch.ones(2), torch.ones(2), "two-dimensional"),
+        (torch.ones((2, 3)), torch.ones(2), "square"),
+        (torch.eye(2), torch.ones(3), "incompatible"),
+    ],
+)
+def test_shape_validation(matrix, rhs, error):
+    solver = DenseLUSolver()
+    if matrix.ndim != 2 or matrix.shape[0] != matrix.shape[1]:
+        with pytest.raises(ValueError, match=error):
+            solver.factorize(matrix)
+        return
+    solver.factorize(matrix)
+    with pytest.raises(ValueError, match=error):
+        solver.solve(rhs)
+
+
+def test_singular_matrix_reports_factorization_failure():
+    solver = DenseLUSolver()
+    matrix = torch.tensor([[1.0, 2.0], [2.0, 4.0]])
+    with pytest.raises(TorchLinearSolveError, match="singular|invalid"):
+        solver.factorize(matrix)
+
+
+@pytest.mark.parametrize("bad", [float("nan"), float("inf")])
+def test_nonfinite_inputs_are_rejected_before_lu(bad):
+    solver = DenseLUSolver()
+    matrix = torch.eye(2)
+    matrix[0, 0] = bad
+    with pytest.raises(ValueError, match="NaN or Inf"):
+        solver.factorize(matrix)
+
+    solver.factorize(torch.eye(2))
+    rhs = torch.ones(2)
+    rhs[0] = bad
+    with pytest.raises(ValueError, match="NaN or Inf"):
+        solver.solve(rhs)
diff --git a/tests/test_torch_osqp_direct.py b/tests/test_torch_osqp_direct.py
new file mode 100644
index 0000000..af5f834
--- /dev/null
+++ b/tests/test_torch_osqp_direct.py
@@ -0,0 +1,177 @@
+import pytest
+import torch
+
+from pygranso.private import torchOSQP as torch_osqp_module
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def _bound_problem(dtype=torch.float64, device="cpu"):
+    device = torch.device(device)
+    H = torch.eye(2, device=device, dtype=dtype)
+    f = torch.tensor([[-1.0], [-2.0]], device=device, dtype=dtype)
+    lower = torch.zeros((2, 1), device=device, dtype=dtype)
+    upper = torch.ones((2, 1), device=device, dtype=dtype)
+    return H, f, None, None, lower, upper
+
+
+def _solve(problem, *, settings=None, workspace=None, algebra="torch"):
+    H, f, A, b, lower, upper = problem
+    options = {"algebra": algebra, "settings": {"return_info": True}}
+    options["settings"].update(settings or {})
+    return solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        lower,
+        upper,
+        f.device,
+        f.dtype == torch.float64,
+        options,
+        workspace,
+    )
+
+
+def test_bound_qp_device_dtype_shape_and_solution(floating_dtype, available_device):
+    solution, info = _solve(_bound_problem(floating_dtype, available_device))
+    tolerance = 3e-4 if floating_dtype == torch.float32 else 1e-7
+    assert solution.shape == (2, 1)
+    assert solution.device.type == available_device.type
+    if available_device.index is not None:
+        assert solution.device.index == available_device.index
+    assert solution.dtype == floating_dtype
+    assert torch.allclose(
+        solution.reshape(-1),
+        torch.tensor([1.0, 1.0], device=available_device, dtype=floating_dtype),
+        atol=tolerance,
+        rtol=tolerance,
+    )
+    assert info["status"] == "solved"
+    assert info["primal_residual"] <= info["eps_primal"]
+    assert info["dual_residual"] <= info["eps_dual"]
+
+
+def test_equality_plus_bounds_and_infinite_bound():
+    dtype = torch.float64
+    H = torch.eye(2, dtype=dtype)
+    f = torch.zeros((2, 1), dtype=dtype)
+    A = torch.tensor([[1.0, 1.0]], dtype=dtype)
+    b = torch.tensor(1.0, dtype=dtype)
+    lower = torch.tensor([[-torch.inf], [0.0]], dtype=dtype)
+    upper = torch.tensor([[torch.inf], [1.0]], dtype=dtype)
+    solution, info = _solve((H, f, A, b, lower, upper))
+    assert torch.allclose(solution.sum(), torch.tensor(1.0, dtype=dtype), atol=1e-7)
+    assert info["status"] == "solved"
+
+
+def test_warm_start_and_lu_reuse_for_vector_update():
+    workspace = TorchOSQPWorkspace()
+    problem = _bound_problem()
+    _, first = _solve(problem, settings={"polishing": False}, workspace=workspace)
+    changed = list(problem)
+    changed[1] = torch.tensor([[-0.5], [-1.5]], dtype=torch.float64)
+    _, second = _solve(tuple(changed), settings={"polishing": False}, workspace=workspace)
+    assert first["factorizations_this_solve"] >= 1
+    assert second["factorizations_this_solve"] == 0
+    assert second["factorization_reused"]
+
+
+def test_matrix_value_update_refactorizes_but_keeps_workspace_state():
+    workspace = TorchOSQPWorkspace()
+    problem = _bound_problem()
+    _solve(problem, settings={"polishing": False}, workspace=workspace)
+    changed = list(problem)
+    changed[0] = 2.0 * changed[0]
+    _solve(tuple(changed), settings={"polishing": False}, workspace=workspace)
+    assert workspace.state is not None
+    assert workspace.linear_solver.factorization_count >= 2
+
+
+def test_scaling_adaptive_rho_and_polishing_are_reported():
+    _, info = _solve(_bound_problem())
+    assert info["scaling_applied"]
+    assert info["scaling_passes"] == 10
+    assert "rho_updates" in info
+    assert info["polishing_status"] == "accepted"
+
+
+def test_requested_rho_change_refactorizes():
+    workspace = TorchOSQPWorkspace()
+    problem = _bound_problem()
+    _solve(problem, settings={"polishing": False, "rho": 0.1}, workspace=workspace)
+    _, info = _solve(
+        problem,
+        settings={"polishing": False, "rho": 0.2},
+        workspace=workspace,
+    )
+    assert info["factorizations_this_solve"] >= 1
+    assert workspace.rho_setting == 0.2
+
+
+def test_requested_sigma_change_refactorizes():
+    workspace = TorchOSQPWorkspace()
+    problem = _bound_problem()
+    _solve(problem, settings={"polishing": False, "sigma": 1e-6}, workspace=workspace)
+    _, info = _solve(
+        problem,
+        settings={"polishing": False, "sigma": 1e-5},
+        workspace=workspace,
+    )
+    assert info["factorizations_this_solve"] >= 1
+    assert not info["factorization_reused"]
+
+
+def test_incompatible_requested_dtype_is_rejected():
+    problem = _bound_problem(torch.float32)
+    with pytest.raises(ValueError, match="requested precision"):
+        solve_osqp_torch_qp(
+            *problem,
+            torch.device("cpu"),
+            True,
+            {"algebra": "torch"},
+            TorchOSQPWorkspace(),
+        )
+
+
+def test_input_validation_rejects_invalid_problem():
+    problem = list(_bound_problem())
+    problem[0] = torch.tensor([[1.0, 1.0], [0.0, 1.0]], dtype=torch.float64)
+    with pytest.raises(ValueError, match="asymmetric"):
+        _solve(tuple(problem))
+
+    problem = list(_bound_problem())
+    problem[4] = torch.ones((2, 1), dtype=torch.float64)
+    problem[5] = torch.zeros((2, 1), dtype=torch.float64)
+    with pytest.raises(ValueError, match="lower bound"):
+        _solve(tuple(problem))
+
+    problem = list(_bound_problem())
+    problem[0][0, 0] = torch.nan
+    with pytest.raises(ValueError, match="NaN or Inf"):
+        _solve(tuple(problem))
+
+
+def test_near_symmetric_p_is_safely_symmetrized():
+    problem = list(_bound_problem())
+    perturbation = 10.0 * torch.finfo(torch.float64).eps
+    problem[0][0, 1] = perturbation
+    solution, info = _solve(tuple(problem))
+    assert torch.all(torch.isfinite(solution))
+    assert info["status_compatible"]
+
+
+def test_optional_convexity_diagnostic_rejects_indefinite_p():
+    problem = list(_bound_problem())
+    problem[0] = torch.diag(torch.tensor([1.0, -1.0], dtype=torch.float64))
+    with pytest.raises(ValueError, match="positive semidefinite"):
+        _solve(tuple(problem), settings={"check_convexity": True})
+
+
+def test_requested_polishing_rejection_raises(monkeypatch):
+    def rejected(P, q, A, l, u, x, z, y, settings):
+        return x, z, y, {"polishing_status": "rejected_no_improvement"}
+
+    monkeypatch.setattr(torch_osqp_module, "_polish_solution", rejected)
+    with pytest.raises(RuntimeError, match="polishing failed"):
+        _solve(_bound_problem())
diff --git a/tests/test_torch_osqp_features.py b/tests/test_torch_osqp_features.py
new file mode 100644
index 0000000..e09d156
--- /dev/null
+++ b/tests/test_torch_osqp_features.py
@@ -0,0 +1,77 @@
+import torch
+
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+from pygranso.private.torchOSQP import (
+    _adaptive_rho_update,
+    _rho_vector,
+    _scale_problem,
+    _scaling_for_problem,
+    _unscale_state,
+)
+
+
+def test_ruiz_scaling_round_trips_primal_and_dual_state():
+    dtype = torch.float64
+    P = torch.diag(torch.tensor([1e-4, 1e4], dtype=dtype))
+    q = torch.tensor([2.0, -3.0], dtype=dtype)
+    A = torch.tensor([[1e3, 0.0], [0.0, 1e-3]], dtype=dtype)
+    l = torch.tensor([-1.0, -2.0], dtype=dtype)
+    u = torch.tensor([1.0, 2.0], dtype=dtype)
+    workspace = TorchOSQPWorkspace()
+    scaling = _scaling_for_problem(workspace, P, q, A, {"scaling": 10})
+    P_s, q_s, A_s, l_s, u_s = _scale_problem(P, q, A, l, u, scaling)
+    assert all(torch.all(torch.isfinite(value)) for value in (P_s, q_s, A_s, l_s, u_s))
+
+    x = torch.tensor([0.25, -0.5], dtype=dtype)
+    z = A @ x
+    y = torch.tensor([0.3, -0.2], dtype=dtype)
+    D, E, cost = scaling["D"], scaling["E"], scaling["cost"]
+    x_o, z_o, y_o = _unscale_state(x / D, z * E, y * cost / E, scaling)
+    assert torch.allclose(x_o, x)
+    assert torch.allclose(z_o, z)
+    assert torch.allclose(y_o, y)
+
+
+def test_adaptive_rho_update_is_deterministic_and_keeps_equality_boost():
+    dtype = torch.float64
+    rho = torch.tensor(0.1, dtype=dtype)
+    equality = torch.tensor([False, True])
+    updated, rho_next, rho_vector = _adaptive_rho_update(
+        rho,
+        equality,
+        torch.tensor(10.0, dtype=dtype),
+        torch.tensor(0.1, dtype=dtype),
+        torch.tensor(1.0, dtype=dtype),
+        torch.tensor(1.0, dtype=dtype),
+        5.0,
+    )
+    assert updated
+    assert rho_next > rho
+    assert torch.allclose(rho_vector, _rho_vector(rho_next, equality))
+    assert rho_vector[1] == 1000.0 * rho_vector[0]
+
+
+def test_polishing_handles_duplicate_equality_and_bound_rows():
+    dtype = torch.float64
+    H = torch.ones((1, 1), dtype=dtype)
+    f = torch.tensor([[-2.0]], dtype=dtype)
+    A = torch.ones((1, 1), dtype=dtype)
+    b = torch.tensor(1.0, dtype=dtype)
+    lower = torch.zeros((1, 1), dtype=dtype)
+    upper = torch.ones((1, 1), dtype=dtype)
+    solution, info = solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        lower,
+        upper,
+        "cpu",
+        True,
+        {"algebra": "torch", "settings": {"return_info": True}},
+        TorchOSQPWorkspace(),
+    )
+    assert torch.allclose(solution, torch.ones_like(solution), atol=1e-8, rtol=1e-8)
+    assert info["polishing_status"] == "accepted"
+    assert info["polishing_active_constraints"] == 1
diff --git a/tests/test_torch_osqp_kkt.py b/tests/test_torch_osqp_kkt.py
new file mode 100644
index 0000000..f8a35d6
--- /dev/null
+++ b/tests/test_torch_osqp_kkt.py
@@ -0,0 +1,48 @@
+import torch
+
+from pygranso.private.torchOSQP import (
+    admm_vector_update,
+    build_kkt_matrix,
+    build_kkt_rhs,
+    recover_z_tilde,
+)
+
+
+def test_kkt_blocks_rhs_and_recovery():
+    P = torch.tensor([[2.0, 0.5], [0.5, 1.0]], dtype=torch.float64)
+    A = torch.tensor([[1.0, -1.0], [0.0, 1.0]], dtype=torch.float64)
+    rho = torch.tensor([0.1, 100.0], dtype=torch.float64)
+    sigma = 1e-6
+    K = build_kkt_matrix(P, A, sigma, rho)
+    assert K.shape == (4, 4)
+    assert torch.allclose(K, K.T)
+    assert torch.allclose(K[:2, :2], P + sigma * torch.eye(2, dtype=P.dtype))
+    assert torch.allclose(K[:2, 2:], A.T)
+    assert torch.allclose(K[2:, :2], A)
+    assert torch.allclose(K[2:, 2:], -torch.diag(rho.reciprocal()))
+
+    x = torch.tensor([0.3, -0.2], dtype=P.dtype)
+    z = torch.tensor([0.1, 0.4], dtype=P.dtype)
+    y = torch.tensor([0.2, -0.5], dtype=P.dtype)
+    q = torch.tensor([-1.0, 2.0], dtype=P.dtype)
+    rhs = build_kkt_rhs(x, z, y, q, sigma, rho)
+    solution = torch.linalg.solve(K, rhs)
+    z_tilde = recover_z_tilde(z, solution[2:], y, rho)
+    assert torch.allclose(z_tilde, A @ solution[:2])
+
+
+def test_shared_admm_vector_update_matches_equations():
+    x_tilde = torch.tensor([1.0])
+    x = torch.tensor([0.0])
+    z_tilde = torch.tensor([2.0])
+    z = torch.tensor([0.5])
+    y = torch.tensor([0.2])
+    rho = torch.tensor([0.1])
+    lower = torch.tensor([0.0])
+    upper = torch.tensor([1.0])
+    x_next, z_next, y_next = admm_vector_update(
+        x_tilde, x, z_tilde, z, y, rho, lower, upper, 1.6
+    )
+    assert torch.allclose(x_next, torch.tensor([1.6]))
+    assert torch.allclose(z_next, torch.tensor([1.0]))
+    assert torch.allclose(y_next, torch.tensor([0.39]))
diff --git a/tests/test_torch_osqp_metamorphic.py b/tests/test_torch_osqp_metamorphic.py
new file mode 100644
index 0000000..2534e01
--- /dev/null
+++ b/tests/test_torch_osqp_metamorphic.py
@@ -0,0 +1,52 @@
+import torch
+
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def _solve(H, f, lower, upper):
+    return solve_osqp_torch_qp(
+        H,
+        f,
+        None,
+        None,
+        lower,
+        upper,
+        "cpu",
+        True,
+        {"algebra": "torch", "settings": {"return_info": True}},
+        TorchOSQPWorkspace(),
+    )
+
+
+def _problem():
+    dtype = torch.float64
+    H = torch.tensor(
+        [[4.0, 0.5, 0.0], [0.5, 2.0, 0.25], [0.0, 0.25, 1.0]],
+        dtype=dtype,
+    )
+    f = torch.tensor([[-1.0], [0.5], [-2.0]], dtype=dtype)
+    lower = -torch.ones((3, 1), dtype=dtype)
+    upper = torch.ones((3, 1), dtype=dtype)
+    return H, f, lower, upper
+
+
+def test_positive_objective_scaling_preserves_minimizer():
+    H, f, lower, upper = _problem()
+    base, base_info = _solve(H, f, lower, upper)
+    scaled, scaled_info = _solve(7.0 * H, 7.0 * f, lower, upper)
+    assert base_info["status_compatible"] and scaled_info["status_compatible"]
+    assert torch.allclose(base, scaled, atol=2e-8, rtol=2e-8)
+
+
+def test_variable_permutation_commutes_with_the_solver():
+    H, f, lower, upper = _problem()
+    base, _ = _solve(H, f, lower, upper)
+    permutation = torch.tensor([2, 0, 1])
+    permuted, _ = _solve(
+        H[permutation][:, permutation],
+        f[permutation],
+        lower[permutation],
+        upper[permutation],
+    )
+    assert torch.allclose(permuted, base[permutation], atol=2e-8, rtol=2e-8)
diff --git a/tests/test_torch_osqp_policy.py b/tests/test_torch_osqp_policy.py
new file mode 100644
index 0000000..ee3f78e
--- /dev/null
+++ b/tests/test_torch_osqp_policy.py
@@ -0,0 +1,249 @@
+import warnings
+
+import pytest
+import torch
+
+from pygranso.private import osqpTorchAdapter as adapter
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def _problem(n=2, device="cpu"):
+    device = torch.device(device)
+    dtype = torch.float64
+    return (
+        torch.eye(n, device=device, dtype=dtype),
+        -torch.ones((n, 1), device=device, dtype=dtype),
+        None,
+        None,
+        torch.zeros((n, 1), device=device, dtype=dtype),
+        torch.ones((n, 1), device=device, dtype=dtype),
+    )
+
+
+def test_auto_cpu_follows_requested_device_and_uses_builtin():
+    H, f, A, b, lower, upper = _problem()
+    _, info = adapter.solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        lower,
+        upper,
+        "cpu",
+        True,
+        {"algebra": "auto", "settings": {"return_info": True}},
+        TorchOSQPWorkspace(),
+    )
+    assert info["backend"] == "builtin"
+    assert info["selection_reason"] == "cpu_target_uses_builtin"
+
+
+def test_builtin_workspace_reuses_structure_for_vector_update():
+    workspace = TorchOSQPWorkspace()
+    problem = _problem()
+    _, first = adapter.solve_osqp_torch_qp(
+        *problem,
+        "cpu",
+        True,
+        {"algebra": "builtin", "settings": {"return_info": True}},
+        workspace,
+    )
+    changed = list(problem)
+    changed[1] = -2.0 * torch.ones_like(changed[1])
+    _, second = adapter.solve_osqp_torch_qp(
+        *changed,
+        "cpu",
+        True,
+        {"algebra": "builtin", "settings": {"return_info": True}},
+        workspace,
+    )
+    assert first["builtin_workspace"]["setups"] == 1
+    assert second["builtin_workspace"]["updates"] == 1
+    assert second["builtin_workspace"]["last_cache_hit"]
+
+
+def test_legacy_solver_settings_warn_and_raise():
+    H, f, A, b, lower, upper = _problem()
+    with pytest.warns(FutureWarning, match="archived"):
+        with pytest.raises(ValueError, match="no longer executable"):
+            adapter.solve_osqp_torch_qp(
+                H,
+                f,
+                A,
+                b,
+                lower,
+                upper,
+                "cpu",
+                True,
+                {"algebra": "torch", "settings": {"linear_solver": "sparse_cg"}},
+            )
+
+
+def test_explicit_oversize_warns_but_remains_torch_selection():
+    n = 1201
+    H = torch.empty((n, n), device="meta")
+    f = torch.empty((n, 1), device="meta")
+    with warnings.catch_warnings(record=True) as caught:
+        selection = adapter._select_backend(
+            "torch", torch.device("cpu"), torch.float64, H, f, None, None
+        )
+    assert selection["backend"] == "torch"
+    assert selection["estimated_kkt_dim"] > adapter.MAX_SUPPORTED_KKT_DIM
+    assert any("exceeds the validated" in str(item.message) for item in caught)
+
+
+def test_auto_failure_records_full_fallback(monkeypatch):
+    if not torch.cuda.is_available():
+        pytest.skip("CUDA is required to select the automatic Torch route.")
+    problem = _problem(device="cuda")
+    monkeypatch.setitem(adapter.PROMOTED_ACCELERATOR_BACKENDS, "cuda", True)
+
+    def fail(*args, **kwargs):
+        raise RuntimeError("synthetic torch failure")
+
+    monkeypatch.setattr(adapter, "_solve_torch_osqp_path", fail)
+    with pytest.warns(RuntimeWarning, match="synthetic torch failure"):
+        _, info = adapter.solve_osqp_torch_qp(
+            *problem,
+            torch.device("cuda"),
+            True,
+            {"algebra": "auto", "settings": {"return_info": True}},
+            TorchOSQPWorkspace(),
+        )
+    fallback = info["fallback"]
+    assert fallback["occurred"]
+    assert fallback["exception_type"] == "RuntimeError"
+    assert fallback["fallback_backend"] == "builtin"
+    assert fallback["device_transfer"]
+
+
+def test_auto_unsolved_status_records_status_and_falls_back(monkeypatch):
+    problem = _problem()
+    monkeypatch.setattr(
+        adapter,
+        "_select_backend",
+        lambda *args, **kwargs: {
+            "requested_backend": "auto",
+            "backend": "torch",
+            "selection_reason": "synthetic_validated_target",
+            "estimated_kkt_dim": 4,
+            "estimated_dense_working_memory_mb": 1.0,
+            "fallback": {"occurred": False},
+        },
+    )
+
+    def unsolved(*args, **kwargs):
+        return torch.zeros((2, 1), dtype=torch.float64), {
+            "status": "max_iter_reached",
+            "status_compatible": False,
+        }
+
+    monkeypatch.setattr(adapter, "_solve_torch_osqp_path", unsolved)
+    with pytest.warns(RuntimeWarning, match="solved-compatible"):
+        _, info = adapter.solve_osqp_torch_qp(
+            *problem,
+            torch.device("cpu"),
+            True,
+            {"algebra": "auto", "settings": {"return_info": True}},
+            TorchOSQPWorkspace(),
+        )
+    assert info["backend"] == "builtin"
+    assert info["fallback"]["trigger"] == "unsolved_status"
+    assert info["fallback"]["status"] == "max_iter_reached"
+    assert info["fallback"]["torch_info"]["status_compatible"] is False
+
+
+def test_unpromoted_cuda_auto_fallback_is_observable():
+    if not torch.cuda.is_available() or torch.version.hip is not None:
+        pytest.skip("An NVIDIA CUDA device is required.")
+    H, f, A, b, lower, upper = _problem(device="cuda")
+    with pytest.warns(RuntimeWarning, match="cuda_not_promoted"):
+        _, info = adapter.solve_osqp_torch_qp(
+            H,
+            f,
+            A,
+            b,
+            lower,
+            upper,
+            "cuda",
+            True,
+            {"algebra": "auto", "settings": {"return_info": True}},
+            TorchOSQPWorkspace(),
+        )
+    assert info["backend"] == "builtin"
+    assert info["selection_reason"] == "cuda_not_promoted"
+    assert info["fallback"]["occurred"]
+    assert info["fallback"]["trigger"] == "selection_policy"
+
+
+def test_auto_memory_preflight_selects_observable_builtin_fallback(monkeypatch):
+    monkeypatch.setattr(adapter, "_accelerator_capability", lambda *args: (True, "ok"))
+    monkeypatch.setattr(adapter, "_memory_limit_mb", lambda *args: 0.0001)
+    H, f, A, b, *_ = _problem(n=10)
+    with pytest.warns(RuntimeWarning, match="memory"):
+        selection = adapter._select_backend(
+            "auto", torch.device("cuda"), torch.float64, H, f, A, b
+        )
+    assert selection["backend"] == "builtin"
+    assert selection["selection_reason"] == "memory_preflight"
+    assert selection["fallback"]["occurred"]
+
+
+def test_mps_float64_auto_fallback_returns_cpu_solution():
+    problem = _problem()
+    with pytest.warns(RuntimeWarning, match="mps_float64_unsupported"):
+        solution, info = adapter.solve_osqp_torch_qp(
+            *problem,
+            torch.device("mps"),
+            True,
+            {"algebra": "auto", "settings": {"return_info": True}},
+            TorchOSQPWorkspace(),
+        )
+    assert solution.device.type == "cpu"
+    assert info["requested_device"] == "mps"
+    assert info["device"] == "cpu"
+    assert info["selection_reason"] == "mps_float64_unsupported"
+    assert info["fallback"]["occurred"]
+
+
+def test_only_three_public_algebra_values_are_accepted():
+    with pytest.raises(ValueError, match="auto.*builtin.*torch"):
+        adapter._normalize_options({"algebra": "cuda"}, torch.float64)
+
+
+def test_explicit_torch_unsolved_status_raises(monkeypatch):
+    problem = _problem()
+
+    def unsolved(*args, **kwargs):
+        return torch.zeros((2, 1), dtype=torch.float64), {
+            "status": "max_iter_reached",
+            "status_compatible": False,
+        }
+
+    monkeypatch.setattr(adapter, "_solve_torch_osqp_path", unsolved)
+    with pytest.raises(RuntimeError, match="max_iter_reached"):
+        adapter.solve_osqp_torch_qp(
+            *problem,
+            torch.device("cpu"),
+            True,
+            {"algebra": "torch", "settings": {"return_info": True}},
+            TorchOSQPWorkspace(),
+        )
+
+
+def test_backend_change_invalidates_complete_workspace():
+    workspace = TorchOSQPWorkspace()
+    workspace.state = {"x": torch.ones(1), "z": torch.ones(1), "y": torch.ones(1)}
+    workspace.active_backend = "torch"
+    assert workspace.ensure_backend("builtin")
+    assert workspace.state is None
+    assert workspace.builtin_cache is None
+    assert workspace.active_backend == "builtin"
+
+
+def test_unindexed_cuda_target_is_canonicalized_to_the_current_device():
+    if not torch.cuda.is_available():
+        pytest.skip("CUDA is unavailable.")
+    canonical = adapter._canonical_device(torch.device("cuda"))
+    assert canonical.type == "cuda"
+    assert canonical.index == torch.cuda.current_device()
diff --git a/tests/test_torch_osqp_randomized.py b/tests/test_torch_osqp_randomized.py
new file mode 100644
index 0000000..c091754
--- /dev/null
+++ b/tests/test_torch_osqp_randomized.py
@@ -0,0 +1,32 @@
+import torch
+
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+
+def test_seeded_feasible_convex_qps_match_builtin(random_seed):
+    generator = torch.Generator().manual_seed(random_seed)
+    dtype = torch.float64
+    n = 2 + random_seed % 5
+    R = torch.randn((n, n), generator=generator, dtype=dtype)
+    H = R.T @ R + 1e-3 * torch.eye(n, dtype=dtype)
+    f = torch.randn((n, 1), generator=generator, dtype=dtype)
+    lower = -torch.ones((n, 1), dtype=dtype)
+    upper = torch.ones((n, 1), dtype=dtype)
+    settings = {
+        "return_info": True,
+        "polishing": True,
+        "scaling": 10,
+        "adaptive_rho": True,
+    }
+    torch_x, torch_info = solve_osqp_torch_qp(
+        H, f, None, None, lower, upper, "cpu", True,
+        {"algebra": "torch", "settings": settings}, TorchOSQPWorkspace()
+    )
+    builtin_x, builtin_info = solve_osqp_torch_qp(
+        H, f, None, None, lower, upper, "cpu", True,
+        {"algebra": "builtin", "settings": settings}, TorchOSQPWorkspace()
+    )
+    assert torch_info["status_compatible"]
+    assert builtin_info["status_compatible"]
+    assert torch.allclose(torch_x, builtin_x, atol=2e-5, rtol=2e-5)
diff --git a/torch_osqp_stability.py b/torch_osqp_stability.py
new file mode 100644
index 0000000..2237b4d
--- /dev/null
+++ b/torch_osqp_stability.py
@@ -0,0 +1,503 @@
+"""Generate reproducible Torch-OSQP stability evidence."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import importlib.metadata
+import json
+import math
+import platform
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import torch
+
+from pygranso.private.osqpTorchAdapter import solve_osqp_torch_qp
+from pygranso.private.osqpWorkspace import TorchOSQPWorkspace
+
+CSV_COLUMNS = (
+    "test_family",
+    "case_name",
+    "seed",
+    "device",
+    "dtype",
+    "builtin_status",
+    "torch_status",
+    "primal_residual",
+    "primal_tolerance",
+    "dual_residual",
+    "dual_tolerance",
+    "builtin_primal_residual",
+    "builtin_primal_tolerance",
+    "builtin_dual_residual",
+    "builtin_dual_tolerance",
+    "objective_builtin",
+    "objective_torch",
+    "relative_objective_gap",
+    "bound_violation",
+    "equality_violation",
+    "linear_residual",
+    "condition_estimate",
+    "support_class",
+    "pass_primal",
+    "pass_dual",
+    "pass_builtin_residuals",
+    "pass_objective",
+    "pass_status",
+    "overall_status",
+    "release_gate",
+    "failure_reason",
+)
+
+
+SUPPORTED_FAMILIES = ("randomized_bounds", "randomized_equality")
+STRESS_FAMILY = "conditioning_stress"
+
+
+def source_tree_fingerprint():
+    """Hash the maintained solver, tests, workflows, scripts, and docs."""
+
+    root = Path(__file__).resolve().parent
+    patterns = (
+        "pygranso/**/*.py",
+        "tests/**/*.py",
+        ".github/workflows/*.yml",
+        "docs/*.md",
+        "scripts/*.py",
+        "bench*.py",
+        "torch_osqp_stability.py",
+        "pyproject.toml",
+        "README.md",
+        ".gitignore",
+    )
+    paths = sorted(
+        {path for pattern in patterns for path in root.glob(pattern) if path.is_file()},
+        key=lambda path: path.relative_to(root).as_posix(),
+    )
+    digest = hashlib.sha256()
+    for path in paths:
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        content = path.read_bytes()
+        digest.update(len(relative).to_bytes(8, "big"))
+        digest.update(relative)
+        digest.update(len(content).to_bytes(8, "big"))
+        digest.update(content)
+    return digest.hexdigest(), len(paths)
+
+
+def make_problem(family, seed, device, dtype):
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    n = 2 + seed % 7
+    if family == STRESS_FAMILY:
+        target_condition = 5e7
+    elif dtype == torch.float32:
+        target_condition = (2.0, 5.0, 10.0, 30.0)[seed % 4]
+    else:
+        target_condition = (1e2, 1e4, 1e5, 1e6)[seed % 4]
+    eigenvalues = torch.logspace(
+        0,
+        math.log10(target_condition),
+        n,
+        dtype=dtype,
+    )
+    Q, _ = torch.linalg.qr(torch.randn((n, n), generator=generator, dtype=dtype))
+    H = Q @ torch.diag(eigenvalues) @ Q.T
+    f = torch.randn((n, 1), generator=generator, dtype=dtype)
+    lower = -torch.ones((n, 1), dtype=dtype)
+    upper = torch.ones((n, 1), dtype=dtype)
+    if family in {"randomized_equality", STRESS_FAMILY}:
+        A = torch.ones((1, n), dtype=dtype)
+        b = torch.tensor(0.25, dtype=dtype)
+    else:
+        A = b = None
+    values = (H, f, A, b, lower, upper)
+    values = tuple(value.to(device=device) if torch.is_tensor(value) else value for value in values)
+    return family, values, float(target_condition)
+
+
+def solve(problem, algebra, settings):
+    H, f, A, b, lower, upper = problem
+    return solve_osqp_torch_qp(
+        H,
+        f,
+        A,
+        b,
+        lower,
+        upper,
+        f.device,
+        f.dtype == torch.float64,
+        {"algebra": algebra, "settings": settings},
+        TorchOSQPWorkspace(),
+    )
+
+
+def estimate_initial_kkt_condition(problem, dtype):
+    """Estimate KKT conditioning on CPU without exercising a backend solver."""
+
+    H, f, A, b, lower, upper = problem
+    del f, b
+    P = H.detach().cpu().to(dtype=torch.float64)
+    n = int(P.shape[0])
+    identity = torch.eye(n, dtype=torch.float64)
+    lower_cpu = lower.detach().cpu().reshape(-1).to(dtype=torch.float64)
+    upper_cpu = upper.detach().cpu().reshape(-1).to(dtype=torch.float64)
+    if A is None:
+        A_osqp = identity
+        l_osqp = lower_cpu
+        u_osqp = upper_cpu
+    else:
+        equality = A.detach().cpu().to(dtype=torch.float64)
+        if equality.ndim == 1:
+            equality = equality.reshape(1, -1)
+        A_osqp = torch.cat((equality, identity), dim=0)
+        rhs = torch.zeros(equality.shape[0], dtype=torch.float64)
+        l_osqp = torch.cat((rhs, lower_cpu))
+        u_osqp = torch.cat((rhs, upper_cpu))
+    equality_mask = torch.isfinite(l_osqp) & torch.isfinite(u_osqp) & torch.isclose(
+        l_osqp,
+        u_osqp,
+        rtol=100.0 * torch.finfo(torch.float64).eps,
+        atol=100.0 * torch.finfo(torch.float64).eps,
+    )
+    rho_vec = torch.full((A_osqp.shape[0],), 0.1, dtype=torch.float64)
+    rho_vec[equality_mask] *= 1000.0
+    top = torch.cat((P + 1e-6 * identity, A_osqp.T), dim=1)
+    bottom = torch.cat((A_osqp, -torch.diag(rho_vec.reciprocal())), dim=1)
+    K = torch.cat((top, bottom), dim=0)
+    try:
+        value = torch.linalg.cond(K).item()
+    except RuntimeError:
+        return math.inf
+    if not math.isfinite(value):
+        return math.inf
+    return float(value)
+
+
+def evaluate(family, seed, device, dtype):
+    family, problem, condition = make_problem(family, seed, device, dtype)
+    H, _f, A, b, lower, upper = problem
+    condition = estimate_initial_kkt_condition(problem, dtype)
+    settings = {
+        "return_info": True,
+        "check_linear_residual": True,
+        "check_condition": False,
+        "eps_abs": 1e-8 if dtype == torch.float64 else 1e-5,
+        "eps_rel": 1e-8 if dtype == torch.float64 else 1e-5,
+    }
+    torch_x, torch_info = solve(problem, "torch", settings)
+    builtin_x, builtin_info = solve(problem, "builtin", settings)
+    objective_scale = max(1.0, abs(builtin_info["objective"]))
+    objective_gap = abs(torch_info["objective"] - builtin_info["objective"]) / objective_scale
+    bounds = torch.maximum(
+        torch.clamp(lower.reshape(-1) - torch_x.reshape(-1), min=0),
+        torch.clamp(torch_x.reshape(-1) - upper.reshape(-1), min=0),
+    )
+    bound_violation = float(torch.max(bounds).item())
+    equality_violation = 0.0
+    if A is not None:
+        equality_violation = float(torch.max(torch.abs(A @ torch_x - b)).item())
+    objective_tolerance = 1e-7 if dtype == torch.float64 else 1e-4
+    pass_primal = torch_info["primal_residual"] <= torch_info["eps_primal"]
+    pass_dual = torch_info["dual_residual"] <= torch_info["eps_dual"]
+    pass_builtin_residuals = (
+        builtin_info["primal_residual"] <= builtin_info["eps_primal"]
+        and builtin_info["dual_residual"] <= builtin_info["eps_dual"]
+    )
+    pass_objective = objective_gap <= objective_tolerance
+    pass_status = bool(
+        torch_info["status_compatible"] and builtin_info["status_compatible"]
+    )
+    passed = (
+        pass_primal
+        and pass_dual
+        and pass_builtin_residuals
+        and pass_objective
+        and pass_status
+    )
+    supported_condition_limit = 1e8 if dtype == torch.float64 else 1e2
+    support_class = (
+        "stress"
+        if family == STRESS_FAMILY or condition > supported_condition_limit
+        else "supported"
+    )
+    failures = []
+    if not pass_primal:
+        failures.append("primal")
+    if not pass_dual:
+        failures.append("dual")
+    if not pass_builtin_residuals:
+        failures.append("builtin_residuals")
+    if not pass_objective:
+        failures.append("objective")
+    if not pass_status:
+        failures.append("status")
+    return {
+        "test_family": family,
+        "case_name": f"{family}_seed_{seed}",
+        "seed": seed,
+        "device": str(device),
+        "dtype": str(dtype),
+        "builtin_status": builtin_info["status"],
+        "torch_status": torch_info["status"],
+        "primal_residual": torch_info["primal_residual"],
+        "primal_tolerance": torch_info["eps_primal"],
+        "dual_residual": torch_info["dual_residual"],
+        "dual_tolerance": torch_info["eps_dual"],
+        "builtin_primal_residual": builtin_info["primal_residual"],
+        "builtin_primal_tolerance": builtin_info["eps_primal"],
+        "builtin_dual_residual": builtin_info["dual_residual"],
+        "builtin_dual_tolerance": builtin_info["eps_dual"],
+        "objective_builtin": builtin_info["objective"],
+        "objective_torch": torch_info["objective"],
+        "relative_objective_gap": objective_gap,
+        "bound_violation": bound_violation,
+        "equality_violation": equality_violation,
+        "linear_residual": torch_info.get("maximum_linear_residual"),
+        "condition_estimate": condition,
+        "support_class": support_class,
+        "pass_primal": pass_primal,
+        "pass_dual": pass_dual,
+        "pass_builtin_residuals": pass_builtin_residuals,
+        "pass_objective": pass_objective,
+        "pass_status": pass_status,
+        "overall_status": "passed" if passed else "failed",
+        "release_gate": (
+            "not_applicable"
+            if support_class == "stress"
+            else "passed"
+            if passed
+            else "failed"
+        ),
+        "failure_reason": "|".join(failures),
+    }, problem
+
+
+def environment_manifest(args):
+    commit = "unknown"
+    dirty = None
+    git_status_entries = None
+    try:
+        commit = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout.strip()
+        status_output = subprocess.run(
+            ["git", "status", "--porcelain"],
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout
+        git_status_entries = [line for line in status_output.splitlines() if line]
+        dirty = bool(git_status_entries)
+    except (OSError, subprocess.SubprocessError):
+        pass
+    hardware = platform.processor() or platform.machine()
+    requested_device = torch.device(args.device)
+    if requested_device.type == "cuda" and torch.cuda.is_available():
+        hardware = torch.cuda.get_device_name(requested_device)
+    source_sha256, source_file_count = source_tree_fingerprint()
+    return {
+        "created_utc": datetime.now(timezone.utc).isoformat(),
+        "git_commit": commit,
+        "git_dirty": dirty,
+        "git_status_entries": git_status_entries,
+        "source_tree_sha256": source_sha256,
+        "source_file_count": source_file_count,
+        "platform": platform.platform(),
+        "python": sys.version,
+        "torch": torch.__version__,
+        "osqp": importlib.metadata.version("osqp"),
+        "device": args.device,
+        "backends": ["builtin", "torch"],
+        "hardware": hardware,
+        "dtype": args.dtype,
+        "families": list(SUPPORTED_FAMILIES),
+        "seeds_per_supported_family": args.seeds,
+        "supported_seeds": list(range(args.seeds)),
+        "stress_seeds": list(range(args.stress_seeds)),
+        "time_limit_seconds": args.time_limit_seconds,
+        "supported_condition_limit": 1e8 if args.dtype == "float64" else 1e2,
+        "stress_condition_limit": 1e10,
+        "condition_estimate_method": "cpu_dense_initial_kkt",
+        "kkt_dimension_limit": 2400,
+        "settings": {
+            "rho": 0.1,
+            "sigma": 1e-6,
+            "alpha": 1.6,
+            "scaling": 10,
+            "adaptive_rho": True,
+            "polishing": True,
+        },
+    }
+
+
+def write_summary(path, rows, manifest):
+    families = sorted({row["test_family"] for row in rows})
+    completed_cases = manifest.get("completed_cases", len(rows))
+    planned_cases = manifest.get("planned_cases", len(rows))
+    lines = [
+        "# Torch OSQP Stability Summary",
+        "",
+        f"- Git commit: `{manifest['git_commit']}`",
+        f"- Device: `{manifest['device']}`",
+        f"- Dtype: `{manifest['dtype']}`",
+        f"- Cases: {completed_cases}/{planned_cases}",
+        f"- Timed out: {manifest.get('timed_out', False)}",
+        f"- Passed: {sum(row['overall_status'] == 'passed' for row in rows)}",
+        f"- Failed: {sum(row['overall_status'] == 'failed' for row in rows)}",
+        f"- Release-gate failures: {sum(row['release_gate'] == 'failed' for row in rows)}",
+        "",
+        "| Test family | Total | Passed | Failed |",
+        "| --- | ---: | ---: | ---: |",
+    ]
+    for family in families:
+        family_rows = [row for row in rows if row["test_family"] == family]
+        passed = sum(row["overall_status"] == "passed" for row in family_rows)
+        lines.append(f"| {family} | {len(family_rows)} | {passed} | {len(family_rows)-passed} |")
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def write_artifacts(output, rows, manifest, started, planned_cases, timed_out):
+    """Write CSV, manifest, and summary for complete or partial stability runs."""
+
+    manifest["elapsed_seconds"] = elapsed = time.perf_counter() - started
+    manifest["completed_cases"] = len(rows)
+    manifest["planned_cases"] = planned_cases
+    manifest["timed_out"] = bool(timed_out)
+    manifest["partial_results"] = bool(timed_out or len(rows) < planned_cases)
+    with (output / "torch_osqp_stability_results.csv").open(
+        "w", newline="", encoding="utf-8"
+    ) as handle:
+        writer = csv.DictWriter(handle, fieldnames=CSV_COLUMNS)
+        writer.writeheader()
+        writer.writerows(rows)
+    (output / "torch_osqp_stability_manifest.json").write_text(
+        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
+    )
+    write_summary(output / "torch_osqp_stability_summary.md", rows, manifest)
+    failures = [row for row in rows if row["release_gate"] == "failed"]
+    observations = [row for row in rows if row["overall_status"] == "failed"]
+    print(
+        f"Stability cases: {len(rows)}/{planned_cases}, "
+        f"numerical failures: {len(observations)}, "
+        f"release-gate failures: {len(failures)}, elapsed: {elapsed:.2f}s"
+    )
+    return elapsed, failures
+
+
+def run(args):
+    started = time.perf_counter()
+    # Capture source provenance before creating output files so the manifest's
+    # dirty flag describes the solver worktree, not its own generated artifacts.
+    manifest = environment_manifest(args)
+    output = Path(args.output)
+    output.mkdir(parents=True, exist_ok=True)
+    reproduction = output / "failures"
+    reproduction.mkdir(parents=True, exist_ok=True)
+    device = torch.device(args.device)
+    dtype = torch.float64 if args.dtype == "float64" else torch.float32
+    rows = []
+    cases = [
+        (family, seed)
+        for family in SUPPORTED_FAMILIES
+        for seed in range(args.seeds)
+    ]
+    cases.extend((STRESS_FAMILY, seed) for seed in range(args.stress_seeds))
+    planned_cases = len(cases)
+    for family, seed in cases:
+        try:
+            row, problem = evaluate(family, seed, device, dtype)
+        except Exception as exc:
+            family, problem, condition = make_problem(family, seed, device, dtype)
+            support_class = "stress" if family == STRESS_FAMILY else "supported"
+            row = {column: None for column in CSV_COLUMNS}
+            row.update(
+                {
+                    "test_family": family,
+                    "case_name": f"{family}_seed_{seed}",
+                    "seed": seed,
+                    "device": str(device),
+                    "dtype": str(dtype),
+                    "condition_estimate": condition,
+                    "support_class": support_class,
+                    "overall_status": "failed",
+                    "release_gate": (
+                        "not_applicable" if support_class == "stress" else "failed"
+                    ),
+                    "failure_reason": f"{type(exc).__name__}: {exc}",
+                }
+            )
+        rows.append(row)
+        if row["overall_status"] != "passed":
+            torch.save(
+                {
+                    "family": family,
+                    "seed": seed,
+                    "problem": tuple(
+                        value.detach().cpu() if torch.is_tensor(value) else value
+                        for value in problem
+                    ),
+                    "result": row,
+                },
+                reproduction / f"{family}_seed_{seed}.pt",
+            )
+        elapsed = time.perf_counter() - started
+        if elapsed > args.time_limit_seconds:
+            manifest["timeout_after_case"] = {
+                "completed_cases": len(rows),
+                "test_family": family,
+                "seed": seed,
+            }
+            elapsed, _failures = write_artifacts(
+                output,
+                rows,
+                manifest,
+                started,
+                planned_cases,
+                timed_out=True,
+            )
+            raise SystemExit(
+                f"Stability bucket exceeded {args.time_limit_seconds}s after "
+                f"{len(rows)}/{planned_cases} cases: {elapsed:.2f}s."
+            )
+    elapsed, failures = write_artifacts(
+        output,
+        rows,
+        manifest,
+        started,
+        planned_cases,
+        timed_out=False,
+    )
+    if elapsed > args.time_limit_seconds:
+        raise SystemExit(
+            f"Stability bucket exceeded {args.time_limit_seconds}s: {elapsed:.2f}s."
+        )
+    if failures:
+        raise SystemExit(1)
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", default="artifacts/torch_osqp_stability")
+    parser.add_argument("--device", default="cpu")
+    parser.add_argument("--dtype", choices=["float32", "float64"], default="float64")
+    parser.add_argument(
+        "--seeds",
+        type=int,
+        default=100,
+        help="Fixed seeds per supported family/backend bucket.",
+    )
+    parser.add_argument("--stress-seeds", type=int, default=100)
+    parser.add_argument("--time-limit-seconds", type=float, default=7200.0)
+    return parser.parse_args(argv)
+
+
+if __name__ == "__main__":
+    run(parse_args())