diff --git a/.github/find-api-model-versions.py b/.github/find-api-model-versions.py
index 619a5f73a..f8959db87 100644
--- a/.github/find-api-model-versions.py
+++ b/.github/find-api-model-versions.py
@@ -10,6 +10,7 @@
 import shlex
 import sys
 from importlib.metadata import version as distribution_version
+from pathlib import Path
 
 from policyengine.bundle import get_current_bundle
 
@@ -98,7 +99,7 @@ def find_api_model_versions() -> dict[str, str]:
 def find_api_model_versions_and_output_to_github() -> None:
     """Find the API model versions and output them to a file for GitHub."""
     versions = find_api_model_versions()
-    with open(os.environ["GITHUB_ENV"], "a") as f:
+    with Path(os.environ["GITHUB_ENV"]).open("a") as f:
         for key, value in versions.items():
             f.write(f"{key}={value}\n")
 
diff --git a/AGENTS.md b/AGENTS.md
index 7cf1033eb..b980d9a53 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -70,66 +70,33 @@ To add or change a rule, read `docs/engineering/skills/rules-registry.md`.
 
 ### API v2 layer boundaries
 
+- Checked: `api.v2.connectors-mutations-no-reads`, `api.v2.connectors-reads-no-mutations`, `api.v2.crud-checks-cover-every-resource`, `api.v2.session-modules-no-queries`, `api.v2.user-services-no-sql`, `api.v2.validators-transformations-no-db`
 - `api.routes.shared-query-parameters`: Routes that accept query parameters define them through the shared typed query models, never with a second manual parser. (doc-only, not checked: follow it yourself)
-- `api.v2.connectors-mutations-no-reads`: v2 mutation connectors (creates, updates, deletes) never issue select or get reads. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
 - `api.v2.connectors-never-commit`: v2 connectors receive a session from the service and never open, commit, roll back or close it. (doc-only, not checked: follow it yourself)
 - `api.v2.connectors-no-cross-calls`: v2 connector modules never call one another to sequence a workflow; the service does the sequencing. (doc-only, not checked: follow it yourself)
-- `api.v2.connectors-reads-no-mutations`: v2 read connectors never insert, add or delete rows. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
-- `api.v2.crud-checks-cover-every-resource`: The v2 CRUD boundary checks find modules by filename, so every resource package is covered, and every connector module is named as a create, read, update or delete module. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
 - `api.v2.routes-no-sessions-or-sql`: v2 route modules never open database sessions or construct SQL; they call one service method and map typed failures to HTTP. (doc-only, not checked: follow it yourself)
 - `api.v2.services-no-sql`: v2 services sequence work but never construct SQL expressions, call Session.exec, or define HTTP response models. (doc-only, not checked: follow it yourself)
-- `api.v2.session-modules-no-queries`: v2 database_session modules own session lifetime only and never build select, insert, update, delete or exec calls. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
-- `api.v2.user-services-no-sql`: v2 user services (identity, accounts, legacy references and user associations) never build or run SQL themselves or import SQLAlchemy; their connectors do. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
-- `api.v2.validators-transformations-no-db`: v2 validators and transformations never import SQLAlchemy or SQLModel query or session APIs. (blocking: pytest `tests/unit/v2/test_data_crud_boundaries.py`)
 
 ### Runtime persistence and route boundaries
 
-- `api.data.runtime-sql-confined`: Raw SQL is confined to the data-access layer; runtime modules and report orchestration use sessions and mapped models. (blocking: pytest `tests/unit/data/test_runtime_sql_boundaries.py`)
-- `api.legacy.removed-layers-stay-removed`: Removed legacy persistence layers, the temporary DAO module and the legacy endpoints package stay removed. (blocking: pytest `tests/unit/data/test_runtime_sql_boundaries.py`, `tests/unit/routes/test_flask_route_boundaries.py`, `tests/unit/services/test_orm_service_boundaries.py`)
-- `api.routes.flask-blueprints-own-urls`: Legacy Flask URLs are owned by blueprints, and the Flask app assembles blueprints without legacy endpoint wiring. (blocking: pytest `tests/unit/routes/test_flask_route_boundaries.py`)
-- `api.routes.no-domain-logic-in-http`: Flask routes delegate domain processing (economy comparison, calculation) to services instead of doing it in the HTTP layer. (blocking: pytest `tests/unit/routes/test_flask_route_boundaries.py`)
-- `api.routes.no-inline-json-errors`: Flask routes never build JSON error responses inline; they use the shared error handling. (blocking: pytest `tests/unit/routes/test_flask_route_boundaries.py`)
-- `api.services.no-direct-queries`: Services never issue database queries or open database connections directly; they delegate persistence to the data-access layer. (blocking: pytest `tests/unit/services/test_local_data_service_boundaries.py`, `tests/unit/services/test_orchestration_service_database_boundaries.py`, `tests/unit/services/test_orm_service_boundaries.py`, `tests/unit/services/test_run_and_spec_service_database_boundaries.py`)
-- `api.services.session-ownership`: Migrated services use sessions and mapped models; their public methods never accept persistence objects, and routes and the economy service never manage sessions. (blocking: pytest `tests/unit/services/test_local_data_service_boundaries.py`, `tests/unit/services/test_orm_service_boundaries.py`)
+- Checked: `api.data.runtime-sql-confined`, `api.legacy.removed-layers-stay-removed`, `api.routes.flask-blueprints-own-urls`, `api.routes.no-domain-logic-in-http`, `api.routes.no-inline-json-errors`, `api.services.no-direct-queries`, `api.services.session-ownership`
 
 ### Import and startup side effects
 
-- `api.catalog.initializer-not-at-startup`: Application startup modules never import the metadata catalog initializer. (blocking: pytest `tests/unit/v2/test_catalog_initialization.py`)
-- `api.startup.fail-closed-configuration`: Default Cloud SQL startup needs no Supabase configuration, and a selected v2 runtime without its database URL fails closed. (blocking: pytest `tests/unit/v2/test_import_side_effects.py`)
-- `api.startup.no-import-side-effects`: Importing v2 modules, starting up and serving a request open no network connections and create no files or runtime SQLite databases. (blocking: pytest `tests/unit/v2/test_import_side_effects.py`)
-- `api.startup.no-runtime-sqlite-modules`: Runtime SQLite modules are absent from the production package. (blocking: pytest `tests/unit/v2/test_import_side_effects.py`)
+- Checked: `api.catalog.initializer-not-at-startup`, `api.startup.fail-closed-configuration`, `api.startup.no-import-side-effects`, `api.startup.no-runtime-sqlite-modules`
 
 ### Data source isolation
 
-- `api.catalog.extractor-import-isolation`: The catalog extractor never imports PolicyEngine core, country packages or v1 metadata directly. (blocking: pytest `tests/unit/v2/test_catalog_extraction.py`)
-- `api.metadata.read-modules-isolated`: v2 metadata read modules never import PolicyEngine packages or v1 metadata sources. (blocking: pytest `tests/unit/v2/test_metadata_service.py`)
-- `api.reports.v1-persistence-only`: The existing report route and service import only v1 persistence. (blocking: pytest `tests/unit/v2/test_report_v1_runtime_selection.py`)
-- `api.stage12.comparison-tables-isolated`: Serving routes and services never read the Stage 12 comparison tables, and production tables never depend on them. (blocking: pytest `tests/unit/v2/test_stage12_comparison_isolation.py`)
-- `api.stage12.retirement-owned`: Retiring the Stage 12 comparison schema stays owned by a named follow-up change in the Stage 12 worker contract. (blocking: pytest `tests/unit/v2/test_stage12_comparison_isolation.py`)
-- `api.v2.single-orm-layer`: v2 models never create a parallel SQLAlchemy ORM layer alongside SQLModel. (blocking: pytest `tests/unit/v2/test_model_persistence.py`)
+- Checked: `api.catalog.extractor-import-isolation`, `api.metadata.read-modules-isolated`, `api.reports.v1-persistence-only`, `api.stage12.comparison-tables-isolated`, `api.stage12.retirement-owned`, `api.v2.single-orm-layer`
 
 ### Migration and schema
 
+- Checked: `api.migration.alembic-v1-qualified`, `api.migration.alembic-v2-qualified`, `api.migration.bundle-supported-by-simulation-api`, `api.migration.contracts-consistent`, `api.migration.cross-database-integration`
 - `api.migration.alembic-autogenerated-only`: Alembic revisions are autogenerated against an explicitly selected v1 or v2 configuration; never hand-written DDL or data operations. (doc-only, not checked: follow it yourself)
-- `api.migration.alembic-v1-qualified`: v1 Alembic revisions qualify against a disposable MySQL database. (blocking: CI job `alembic-v1-check`)
-- `api.migration.alembic-v2-qualified`: v2 Alembic revisions qualify against a disposable Postgres database, and alembic check finds no schema drift. (blocking: CI job `alembic-v2-check`)
-- `api.migration.bundle-supported-by-simulation-api`: A PolicyEngine bundle version change is supported by the simulation API before it merges. (blocking: CI job `ensure-policyengine-bundle-supported-by-simulation-api`)
-- `api.migration.contracts-consistent`: Migration route groups and workflow contracts are internally consistent, and their generated docs are current. (blocking: quality guard `migration-contracts`)
-- `api.migration.cross-database-integration`: Cross-database integration tests pass against real MySQL and Postgres. (blocking: CI job `v2-integration-check`)
 
 ### Code quality and types
 
-- `api.quality.alembic-revisions-unused-imports`: Ruff doesn't lint Alembic revision files (lint.exclude in pyproject.toml), because they must stay exactly as Alembic generates them. (advisory: nothing, not blocking)
-- `api.quality.ci-cd-scripts-ruff-exemptions`: CI/CD scripts under .github may print their results, fetch fixed URLs and import the lazily loaded packages at module level (T201, S310, TID253); every other ruff rule applies to them. (blocking: ruff per-file ignore of S310, T201, TID253 for `.github/**`)
-- `api.quality.command-line-modules-ruff-exemptions`: Application modules that also run as command-line programs (if __name__ == "__main__") may print their output (T201); every other ruff rule applies to them. (blocking: ruff per-file ignore of T201 for `policyengine_api/{data/v2/catalog/initialization,data/v2/household_migration_qualification,data/v2/policy_migration_qualification,data/v2/user_association_migration_qualification,worker_spm_release}.py`)
-- `api.quality.command-line-scripts-ruff-exemptions`: Command-line scripts under scripts/ may print their output, run other programs, fetch fixed URLs, stamp today's date, pick random samples and ignore a failed best-effort step (T201, S603, S607, S310, DTZ011, S311, S110); every other ruff rule applies to them. (blocking: ruff per-file ignore of DTZ011, S110, S310, S311, S603, S607, T201 for `scripts/**`)
-- `api.quality.environment-variables-load`: Required environment variables and credentials load in a deployed-like environment. (blocking: CI job `test_env_vars`)
-- `api.quality.mypy-v2`: Shared query models, FastAPI dependencies, v2 routes and services, and the user sign-in and account-deletion libraries pass mypy with untyped definitions disallowed. (blocking: mypy)
-- `api.quality.ruff-format`: All Python files are formatted with ruff format. (blocking: ruff format)
-- `api.quality.ruff-lint`: All Python code passes ruff check with every rule family selected in pyproject.toml, with no ratchet; families are added one themed group at a time until the selection is ALL. (blocking: ruff check (A, ANN, BLE, D, DTZ, E, E4, E7, E9, EM, ERA, EXE, F, FAST, FIX, FLY, FURB, G, I, INP, LOG, N, PIE, PLC, PYI, RET, RSE, S, SLF, T20, TC, TD, TID253, TRY, UP, W))
-- `api.quality.runtime-evaluated-models-resolve`: Every package model is one ruff treats as runtime-evaluated (a base resolves, through the import in its own module, to a name in runtime-evaluated-base-classes, or is a same-module class that does), and every Pydantic model and SQLAlchemy mapper resolves its annotations once the package is imported. (blocking: pytest `tests/unit/test_runtime_evaluated_annotations.py`)
-- `api.quality.tests-pass`: The unit, contract and to-refactor test suites pass. (blocking: CI job `test`)
-- `api.quality.tests-ruff-exemptions`: Test files may use pytest's bare assert, need no docstrings, annotations or named constants for magic numbers, and may reach into private members, live outside packages and import inside a test (S101, D1, ANN, PLR2004, SLF001, INP001, PLC0415). They may also use fake credentials, naive datetimes, subprocess calls to repository scripts, SQL built from strings and prints (S105, S106, DTZ001, DTZ011, S603, S607, S608, T201), and may import the lazily loaded packages at module level (TID253). Every other ruff rule applies to tests. (blocking: ruff per-file ignore of ANN, D1, DTZ001, DTZ011, INP001, PLC0415, PLR2004, S101, S105, S106, S603, S607, S608, SLF001, T201, TID253 for `**/tests/**`)
+- Checked: `api.quality.alembic-revisions-unused-imports`, `api.quality.ci-cd-scripts-ruff-exemptions`, `api.quality.command-line-modules-ruff-exemptions`, `api.quality.command-line-scripts-ruff-exemptions`, `api.quality.environment-variables-load`, `api.quality.mypy-v2`, `api.quality.ruff-format`, `api.quality.ruff-lint`, `api.quality.runtime-evaluated-models-resolve`, `api.quality.tests-pass`, `api.quality.tests-ruff-exemptions`, `api.quality.unittest-ruff-exemptions`
 
 ### Observability
 
@@ -138,21 +105,14 @@ To add or change a rule, read `docs/engineering/skills/rules-registry.md`.
 
 ### CI workflows and scripts
 
-- `api.ci.multiline-run-is-script`: A GitHub Actions run: block holds one line of code and no chained commands (&&, ||, ;); anything more lives in a tested script under .github/scripts/, called from a single-line step. (blocking: quality guard `ci-scripts`)
-- `api.ci.shell-scripts-pass-shellcheck`: Every shell script under .github/scripts/ passes shellcheck. (blocking: quality guard `ci-scripts`)
-- `api.ci.workflow-scripts-tested`: Every shell script a workflow calls is run by at least one test. (blocking: quality guard `ci-scripts`)
+- Checked: `api.ci.multiline-run-is-script`, `api.ci.shell-scripts-pass-shellcheck`, `api.ci.workflow-scripts-tested`
 
 ### Process and repository hygiene
 
-- `api.agents.adapters-point-to-agents-md`: CLAUDE.md and .github/copilot-instructions.md only point to AGENTS.md; skills and rules are listed in AGENTS.md alone. (blocking: quality guard `rules-registry`)
+- Checked: `api.agents.adapters-point-to-agents-md`, `api.process.changelog-fragment`, `api.process.cloud-run-image-builds`, `api.process.docker-image-builds`, `api.process.rules-registry`, `api.process.stacked-prs-full-ci-at-bottom`
 - `api.process.agents-never-bypass`: Agents never bypass branch rules, even with admin credentials: no gh pr merge --admin and no bypass option; a blocked merge is reported to a human. (doc-only, not checked: follow it yourself)
-- `api.process.changelog-fragment`: Every PR adds a changelog.d fragment. (blocking: CI job `check-changelog`)
-- `api.process.cloud-run-image-builds`: The Cloud Run container image builds. (blocking: CI job `test_cloud_run_container_builds`)
-- `api.process.docker-image-builds`: The API Docker image builds. (blocking: CI job `test_container_builds`)
 - `api.process.makefile-phony`: Command-only Makefile targets are declared in .PHONY, and .PHONY stays in sync when targets are renamed or removed. (doc-only, not checked: follow it yourself)
 - `api.process.pr-tracking-issue`: Every PR has a tracking issue in this repository, and the first line of its description is Fixes #ISSUE_NUMBER. (doc-only, not checked: follow it yourself)
 - `api.process.rule-machinery-code-owned`: Changes to the rule machinery (rules/, scripts/rules/, scripts/guards/, scripts/run_quality_guards.py and CODEOWNERS) need approval from a core developer other than the author. (doc-only, not checked: follow it yourself)
-- `api.process.rules-registry`: Every rule is registered in rules/registry.toml, is enforced where it claims to be, and its rendered views are current. (blocking: quality guard `rules-registry`)
-- `api.process.stacked-prs-full-ci-at-bottom`: In a stack of pull requests, only the lowest unmerged one runs the full PR workflow. Every pr.yml job is needed by the CI complete gate, which fails on the pull requests above it and otherwise passes only when every job passed, so a stack merges bottom-up and nothing merges untested. (blocking: pytest `tests/unit/test_ci_complete_gate.py`)
 
 <!-- END GENERATED: rules -->
diff --git a/changelog.d/ruff-idioms-arguments.changed.md b/changelog.d/ruff-idioms-arguments.changed.md
new file mode 100644
index 000000000..2f14cc830
--- /dev/null
+++ b/changelog.d/ruff-idioms-arguments.changed.md
@@ -0,0 +1 @@
+Enabled ruff's argument, idiom and pytest-style rules (ARG, ASYNC, B, C4, FBT, PD, PERF, PGH, PLW, PT, PTH, RUF, SIM): unused arguments are removed, underscored or explained (test stand-ins that mirror a real signature take ARG001, ARG002 and ARG005 as file-level test exceptions instead), tests request side-effect fixtures with usefixtures and match the exception messages they expect, boolean options of internal helpers are keyword-only, best-effort telemetry and logging calls that swallow any failure use contextlib.suppress with the reason as a comment, and re-raised errors keep their cause; published schemas and the HTTP API are unchanged, and the shared rules tool's unittest tests are exempt from pytest-style rules.
diff --git a/dashboard/experiments/gpt4_api_user.py b/dashboard/experiments/gpt4_api_user.py
index 154144fe4..35a643c19 100644
--- a/dashboard/experiments/gpt4_api_user.py
+++ b/dashboard/experiments/gpt4_api_user.py
@@ -66,7 +66,7 @@ def embed(prompt: str, engine: str = "text-embedding-ada-002") -> list[float]:
     lambda x: cosine_similarity(x, embedding)
 )
 
-top5 = embeddings_df.sort_values("similarities", ascending=False).head(5)["json"].values
+top5 = embeddings_df.sort_values("similarities", ascending=False).head(5)["json"].values  # noqa: PD011  # a string column, which pandas 3 stores in an extension array that .to_numpy() would convert
 # display in streamlit
 
 
diff --git a/docs/generated/rules.md b/docs/generated/rules.md
index 849cff093..cc71759bf 100644
--- a/docs/generated/rules.md
+++ b/docs/generated/rules.md
@@ -8,11 +8,11 @@ Every rule that governs `policyengine-api` is listed here with how it is enforce
 
 | Tier | enforced | ratcheted | advisory | doc-only | Total |
 | --- | ---: | ---: | ---: | ---: | ---: |
-| mechanical | 47 | 0 | 1 | 12 | 60 |
+| mechanical | 48 | 0 | 1 | 12 | 61 |
 | metric | 0 | 0 | 0 | 0 | 0 |
 | judgment | 0 | 0 | 0 | 0 | 0 |
 
-**Blocking:** 47 of 60 rules.
+**Blocking:** 48 of 61 rules.
 
 ## Gaps
 
@@ -275,10 +275,11 @@ flowchart LR
 | `api.quality.environment-variables-load` | Required environment variables and credentials load in a deployed-like environment. | mechanical | enforced | yes | CI job `test_env_vars` | `pr.yml:test_env_vars` | — |
 | `api.quality.mypy-v2` | Shared query models, FastAPI dependencies, v2 routes and services, and the user sign-in and account-deletion libraries pass mypy with untyped definitions disallowed. | mechanical | enforced | yes | mypy | `pr.yml:typecheck-v2` | — |
 | `api.quality.ruff-format` | All Python files are formatted with ruff format. | mechanical | enforced | yes | ruff format | `pr.yml:lint` | — |
-| `api.quality.ruff-lint` | All Python code passes ruff check with every rule family selected in pyproject.toml, with no ratchet; families are added one themed group at a time until the selection is ALL. | mechanical | enforced | yes | ruff check (A, ANN, BLE, D, DTZ, E, E4, E7, E9, EM, ERA, EXE, F, FAST, FIX, FLY, FURB, G, I, INP, LOG, N, PIE, PLC, PYI, RET, RSE, S, SLF, T20, TC, TD, TID253, TRY, UP, W) | `pr.yml:lint` | — |
+| `api.quality.ruff-lint` | All Python code passes ruff check with every rule family selected in pyproject.toml, with no ratchet; families are added one themed group at a time until the selection is ALL. | mechanical | enforced | yes | ruff check (A, ANN, ARG, ASYNC, B, BLE, C4, D, DTZ, E, E4, E7, E9, EM, ERA, EXE, F, FAST, FBT, FIX, FLY, FURB, G, I, INP, LOG, N, PD, PERF, PGH, PIE, PLC, PLW, PT, PTH, PYI, RET, RSE, RUF, S, SIM, SLF, T20, TC, TD, TID253, TRY, UP, W) | `pr.yml:lint` | — |
 | `api.quality.runtime-evaluated-models-resolve` | Every package model is one ruff treats as runtime-evaluated (a base resolves, through the import in its own module, to a name in runtime-evaluated-base-classes, or is a same-module class that does), and every Pydantic model and SQLAlchemy mapper resolves its annotations once the package is imported. | mechanical | enforced | yes | pytest `tests/unit/test_runtime_evaluated_annotations.py` | `pr.yml:test` | **unproven** |
 | `api.quality.tests-pass` | The unit, contract and to-refactor test suites pass. | mechanical | enforced | yes | CI job `test` | `pr.yml:test` | — |
-| `api.quality.tests-ruff-exemptions` | Test files may use pytest's bare assert, need no docstrings, annotations or named constants for magic numbers, and may reach into private members, live outside packages and import inside a test (S101, D1, ANN, PLR2004, SLF001, INP001, PLC0415). They may also use fake credentials, naive datetimes, subprocess calls to repository scripts, SQL built from strings and prints (S105, S106, DTZ001, DTZ011, S603, S607, S608, T201), and may import the lazily loaded packages at module level (TID253). Every other ruff rule applies to tests. | mechanical | enforced | yes | ruff per-file ignore of ANN, D1, DTZ001, DTZ011, INP001, PLC0415, PLR2004, S101, S105, S106, S603, S607, S608, SLF001, T201, TID253 for `**/tests/**` | `pr.yml:lint` | — |
+| `api.quality.tests-ruff-exemptions` | Test files may use pytest's bare assert, need no docstrings, annotations or named constants for magic numbers, and may reach into private members, live outside packages and import inside a test (S101, D1, ANN, PLR2004, SLF001, INP001, PLC0415). They may also use fake credentials, naive datetimes, subprocess calls to repository scripts, SQL built from strings and prints (S105, S106, DTZ001, DTZ011, S603, S607, S608, T201), may import the lazily loaded packages at module level (TID253), and may leave a stand-in's arguments unused (ARG001, ARG002, ARG005). Every other ruff rule applies to tests. | mechanical | enforced | yes | ruff per-file ignore of ANN, ARG001, ARG002, ARG005, D1, DTZ001, DTZ011, INP001, PLC0415, PLR2004, S101, S105, S106, S603, S607, S608, SLF001, T201, TID253 for `**/tests/**` | `pr.yml:lint` | — |
+| `api.quality.unittest-ruff-exemptions` | The shared rules tool's tests use unittest, because the tool needs only the standard library, so ruff's pytest-style rules (PT) don't apply to them. | mechanical | enforced | yes | ruff per-file ignore of PT for `scripts/rules/tests/**` | `pr.yml:lint` | — |
 
 ```mermaid
 flowchart LR
@@ -300,14 +301,16 @@ flowchart LR
   r_api_quality_ruff_format("api.quality.ruff-format (enforced)")
   e_ruff_format["ruff format"]
   r_api_quality_ruff_lint("api.quality.ruff-lint (enforced)")
-  e_ruff_check__A__ANN__BLE__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FIX__FLY__FURB__G__I__INP__LOG__N__PIE__PLC__PYI__RET__RSE__S__SLF__T20__TC__TD__TID253__TRY__UP__W_["ruff check (A, ANN, BLE, D, DTZ, E, E4, E7, E9, EM, ERA, EXE, F, FAST, FIX, FLY, FURB, G, I, INP, LOG, N, PIE, PLC, PYI, RET, RSE, S, SLF, T20, TC, TD, TID253, TRY, UP, W)"]
+  e_ruff_check__A__ANN__ARG__ASYNC__B__BLE__C4__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FBT__FIX__FLY__FURB__G__I__INP__LOG__N__PD__PERF__PGH__PIE__PLC__PLW__PT__PTH__PYI__RET__RSE__RUF__S__SIM__SLF__T20__TC__TD__TID253__TRY__UP__W_["ruff check (A, ANN, ARG, ASYNC, B, BLE, C4, D, DTZ, E, E4, E7, E9, EM, ERA, EXE, F, FAST, FBT, FIX, FLY, FURB, G, I, INP, LOG, N, PD, PERF, PGH, PIE, PLC, PLW, PT, PTH, PYI, RET, RSE, RUF, S, SIM, SLF, T20, TC, TD, TID253, TRY, UP, W)"]
   r_api_quality_runtime_evaluated_models_resolve("api.quality.runtime-evaluated-models-resolve (enforced)")
   e_pytest_tests_unit_test_runtime_evaluated_annotations_py["pytest tests/unit/test_runtime_evaluated_annotations.py"]
   j_CI_pr_yml_test["CI pr.yml:test"]
   r_api_quality_tests_pass("api.quality.tests-pass (enforced)")
   e_CI_job_test["CI job test"]
   r_api_quality_tests_ruff_exemptions("api.quality.tests-ruff-exemptions (enforced)")
-  e_ruff_per_file_ignore_of_ANN__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___["ruff per-file ignore of ANN, D1, DTZ001, DTZ011, INP001, PLC0415, PLR2004, S101, S105, S106, S603, S607, S608, SLF001, T201, TID253 for **/tests/**"]
+  e_ruff_per_file_ignore_of_ANN__ARG001__ARG002__ARG005__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___["ruff per-file ignore of ANN, ARG001, ARG002, ARG005, D1, DTZ001, DTZ011, INP001, PLC0415, PLR2004, S101, S105, S106, S603, S607, S608, SLF001, T201, TID253 for **/tests/**"]
+  r_api_quality_unittest_ruff_exemptions("api.quality.unittest-ruff-exemptions (enforced)")
+  e_ruff_per_file_ignore_of_PT_for_scripts_rules_tests___["ruff per-file ignore of PT for scripts/rules/tests/**"]
   r_api_quality_alembic_revisions_unused_imports -.-> gap_unenforced
   r_api_quality_ci_cd_scripts_ruff_exemptions --> e_ruff_per_file_ignore_of_S310__T201__TID253_for__github___
   e_ruff_per_file_ignore_of_S310__T201__TID253_for__github___ --> j_CI_pr_yml_lint
@@ -321,14 +324,16 @@ flowchart LR
   e_mypy --> j_CI_pr_yml_typecheck_v2
   r_api_quality_ruff_format --> e_ruff_format
   e_ruff_format --> j_CI_pr_yml_lint
-  r_api_quality_ruff_lint --> e_ruff_check__A__ANN__BLE__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FIX__FLY__FURB__G__I__INP__LOG__N__PIE__PLC__PYI__RET__RSE__S__SLF__T20__TC__TD__TID253__TRY__UP__W_
-  e_ruff_check__A__ANN__BLE__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FIX__FLY__FURB__G__I__INP__LOG__N__PIE__PLC__PYI__RET__RSE__S__SLF__T20__TC__TD__TID253__TRY__UP__W_ --> j_CI_pr_yml_lint
+  r_api_quality_ruff_lint --> e_ruff_check__A__ANN__ARG__ASYNC__B__BLE__C4__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FBT__FIX__FLY__FURB__G__I__INP__LOG__N__PD__PERF__PGH__PIE__PLC__PLW__PT__PTH__PYI__RET__RSE__RUF__S__SIM__SLF__T20__TC__TD__TID253__TRY__UP__W_
+  e_ruff_check__A__ANN__ARG__ASYNC__B__BLE__C4__D__DTZ__E__E4__E7__E9__EM__ERA__EXE__F__FAST__FBT__FIX__FLY__FURB__G__I__INP__LOG__N__PD__PERF__PGH__PIE__PLC__PLW__PT__PTH__PYI__RET__RSE__RUF__S__SIM__SLF__T20__TC__TD__TID253__TRY__UP__W_ --> j_CI_pr_yml_lint
   r_api_quality_runtime_evaluated_models_resolve --> e_pytest_tests_unit_test_runtime_evaluated_annotations_py
   e_pytest_tests_unit_test_runtime_evaluated_annotations_py --> j_CI_pr_yml_test
   r_api_quality_tests_pass --> e_CI_job_test
   e_CI_job_test --> j_CI_pr_yml_test
-  r_api_quality_tests_ruff_exemptions --> e_ruff_per_file_ignore_of_ANN__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___
-  e_ruff_per_file_ignore_of_ANN__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___ --> j_CI_pr_yml_lint
+  r_api_quality_tests_ruff_exemptions --> e_ruff_per_file_ignore_of_ANN__ARG001__ARG002__ARG005__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___
+  e_ruff_per_file_ignore_of_ANN__ARG001__ARG002__ARG005__D1__DTZ001__DTZ011__INP001__PLC0415__PLR2004__S101__S105__S106__S603__S607__S608__SLF001__T201__TID253_for____tests___ --> j_CI_pr_yml_lint
+  r_api_quality_unittest_ruff_exemptions --> e_ruff_per_file_ignore_of_PT_for_scripts_rules_tests___
+  e_ruff_per_file_ignore_of_PT_for_scripts_rules_tests___ --> j_CI_pr_yml_lint
 ```
 
 ## Observability
diff --git a/migrations/v2/env.py b/migrations/v2/env.py
index b1b88bb38..6f84f08c3 100644
--- a/migrations/v2/env.py
+++ b/migrations/v2/env.py
@@ -34,7 +34,7 @@ def _include_application_object(
     _object: SchemaItem,
     name: str | None,
     type_: NameFilterType,
-    _reflected: bool,
+    _reflected: bool,  # noqa: FBT001  # Alembic calls include_object with positional arguments
     _compare_to: SchemaItem | None,
 ) -> bool:
     """Keep Alembic's own version table outside application drift."""
diff --git a/policyengine_api/asgi_factory.py b/policyengine_api/asgi_factory.py
index 0095e480e..aa3499585 100644
--- a/policyengine_api/asgi_factory.py
+++ b/policyengine_api/asgi_factory.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any
@@ -238,17 +239,17 @@ async def add_request_context_and_migration_logging(
                     context_token = _asgi_request_id.set(request_id)
             except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
                 pass
-            try:
+            # Telemetry must never fail the request.
+            with contextlib.suppress(Exception):
                 request_runtime.set_context(
                     request_id=request_id,
                 )
-            except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                pass
 
         def log_native_route(status_code: int) -> None:
             if not native_request:
                 return
-            try:
+            # Migration logging must never fail the request.
+            with contextlib.suppress(Exception):
                 log_migration_request(
                     request_id=request_id,
                     method=request.method,
@@ -261,8 +262,6 @@ def log_native_route(status_code: int) -> None:
                     ),
                     route_impl=RouteImplementation.FASTAPI_NATIVE,
                 )
-            except Exception:  # noqa: BLE001, S110  # migration logging must never fail the request
-                pass
 
         def finish_native_route(
             status_code: int,
@@ -271,21 +270,18 @@ def finish_native_route(
             if not native_request:
                 return
             resolved_route = getattr(request.scope.get("route"), "path", initial_route)
-            try:
+            # Telemetry must never fail the request.
+            with contextlib.suppress(Exception):
                 request_runtime.update_request_route(resolved_route)
-            except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                pass
-            try:
+            # Telemetry must never fail the request.
+            with contextlib.suppress(Exception):
                 request_runtime.update_request_status(status_code)
-            except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                pass
-            try:
+            # Telemetry must never fail the request.
+            with contextlib.suppress(Exception):
                 request_runtime.end_request(
                     status_code=status_code,
                     error=error,
                 )
-            except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                pass
 
         try:
             try:
@@ -301,15 +297,14 @@ def finish_native_route(
                 )
             )
             if native_request and response_observability_id is not None:
-                try:
+                # Telemetry must never fail the request.
+                with contextlib.suppress(Exception):
                     # Route-level spans have completed at this point, so this
                     # call applies the selected calculation identifier to the
                     # still-current server request span.
                     request_runtime.set_context(
                         observability_id=response_observability_id
                     )
-                except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                    pass
             if native_request:
                 try:
                     for name, value in request_runtime.response_headers().items():
diff --git a/policyengine_api/constants.py b/policyengine_api/constants.py
index 492bbde03..a4110cb3c 100644
--- a/policyengine_api/constants.py
+++ b/policyengine_api/constants.py
@@ -59,7 +59,7 @@ def get_py_manifest() -> Any:  # noqa: ANN401  # SimplePath, which open() reject
 
 def _load_policyengine_bundle() -> dict | None:
     try:
-        with open(get_py_manifest()) as manifest_file:
+        with Path(get_py_manifest()).open() as manifest_file:
             manifest = json.load(manifest_file)
     except Exception as exc:
         msg = (
@@ -162,11 +162,11 @@ def get_bundle_default_dataset_option(country_id: str) -> dict:
     }
     COUNTRY_PACKAGE_VERSIONS = {
         country: _resolve_distribution_version(_dist_versions, package_name)
-        for country, package_name in zip(COUNTRIES, COUNTRY_PACKAGE_NAMES)
+        for country, package_name in zip(COUNTRIES, COUNTRY_PACKAGE_NAMES, strict=True)
     }
 except Exception:  # noqa: BLE001  # unreadable package metadata falls back to 0.0.0; import must not fail
     _dist_versions = {}
-    COUNTRY_PACKAGE_VERSIONS = {country: "0.0.0" for country in COUNTRIES}
+    COUNTRY_PACKAGE_VERSIONS = dict.fromkeys(COUNTRIES, "0.0.0")
 
 _policyengine_bundle = _load_policyengine_bundle()
 _bundle_package_versions = _resolve_bundle_package_versions(_policyengine_bundle)
diff --git a/policyengine_api/country.py b/policyengine_api/country.py
index 94aa6ff6a..caeb5ff07 100644
--- a/policyengine_api/country.py
+++ b/policyengine_api/country.py
@@ -1,5 +1,6 @@
 """Loaded country tax-benefit systems, their metadata and household calculation."""
 
+import contextlib
 import importlib
 import inspect
 import json
@@ -138,26 +139,26 @@ def __init__(self, country_package_name: str, country_id: str) -> None:
     def build_metadata(self) -> None:
         """Build the JSON-safe metadata document served by the metadata endpoints."""
         self.metadata = self._json_safe(
-            dict(
-                variables=self.build_variables(),
-                parameters=self.build_parameters(),
-                entities=self.build_entities(),
-                variableModules=self.tax_benefit_system.variable_module_metadata,
-                economy_options=self.build_microsimulation_options(),
-                current_law_id={
+            {
+                "variables": self.build_variables(),
+                "parameters": self.build_parameters(),
+                "entities": self.build_entities(),
+                "variableModules": self.tax_benefit_system.variable_module_metadata,
+                "economy_options": self.build_microsimulation_options(),
+                "current_law_id": {
                     "uk": 1,
                     "us": 2,
                     "ca": 3,
                     "ng": 4,
                     "il": 5,
                 }[self.country_id],
-                basicInputs=self.tax_benefit_system.basic_inputs,
-                modelled_policies=self.tax_benefit_system.modelled_policies,
-                spm=spm_metadata(self.country_id),
-                version=get_package_version(
+                "basicInputs": self.tax_benefit_system.basic_inputs,
+                "modelled_policies": self.tax_benefit_system.modelled_policies,
+                "spm": spm_metadata(self.country_id),
+                "version": get_package_version(
                     self.country_package_name.replace("_", "-")
                 ),
-            )
+            }
         )
 
     def _json_safe(
@@ -181,7 +182,7 @@ def build_microsimulation_options(self) -> dict:
         """Build the regions, time periods and datasets offered for economy runs."""
         # Shape: { region: [{ name: "uk", label: "the UK" }],
         #   time_period: [{ name: 2022, label: "2022", ... }] }
-        options = dict()
+        options = {}
         if self.country_id == "uk":
             constituency_names_path = (
                 Path(__file__).parent / "data" / "constituencies_2024.csv"
@@ -189,41 +190,41 @@ def build_microsimulation_options(self) -> dict:
             constituency_names = pd.read_csv(constituency_names_path)
             constituency_names = constituency_names.sort_values("name")
             region = [
-                dict(name="uk", label="the UK", type="national"),
-                dict(name="country/england", label="England", type="country"),
-                dict(name="country/scotland", label="Scotland", type="country"),
-                dict(name="country/wales", label="Wales", type="country"),
-                dict(name="country/ni", label="Northern Ireland", type="country"),
+                {"name": "uk", "label": "the UK", "type": "national"},
+                {"name": "country/england", "label": "England", "type": "country"},
+                {"name": "country/scotland", "label": "Scotland", "type": "country"},
+                {"name": "country/wales", "label": "Wales", "type": "country"},
+                {"name": "country/ni", "label": "Northern Ireland", "type": "country"},
             ]
-            for i in range(len(constituency_names)):
-                region.append(
-                    dict(
-                        name=f"constituency/{constituency_names.iloc[i]['name']}",
-                        label=constituency_names.iloc[i]["name"],
-                        type="constituency",
-                    )
-                )
+            region.extend(
+                {
+                    "name": f"constituency/{constituency_names.iloc[i]['name']}",
+                    "label": constituency_names.iloc[i]["name"],
+                    "type": "constituency",
+                }
+                for i in range(len(constituency_names))
+            )
             local_authority_names_path = (
                 Path(__file__).parent / "data" / "local_authorities_2021.csv"
             )
             local_authority_names = pd.read_csv(local_authority_names_path)
             local_authority_names = local_authority_names.sort_values("name")
-            for i in range(len(local_authority_names)):
-                region.append(
-                    dict(
-                        name=f"local_authority/{local_authority_names.iloc[i]['name']}",
-                        label=local_authority_names.iloc[i]["name"],
-                        type="local_authority",
-                    )
-                )
+            region.extend(
+                {
+                    "name": f"local_authority/{local_authority_names.iloc[i]['name']}",
+                    "label": local_authority_names.iloc[i]["name"],
+                    "type": "local_authority",
+                }
+                for i in range(len(local_authority_names))
+            )
             time_period = [
-                dict(name=2024, label="2024"),
-                dict(name=2025, label="2025"),
-                dict(name=2026, label="2026"),
-                dict(name=2027, label="2027"),
-                dict(name=2028, label="2028"),
-                dict(name=2029, label="2029"),
-                dict(name=2030, label="2030"),
+                {"name": 2024, "label": "2024"},
+                {"name": 2025, "label": "2025"},
+                {"name": 2026, "label": "2026"},
+                {"name": 2027, "label": "2027"},
+                {"name": 2028, "label": "2028"},
+                {"name": 2029, "label": "2029"},
+                {"name": 2030, "label": "2030"},
             ]
             datasets = [get_bundle_default_dataset_option("uk")]
             options["region"] = region
@@ -231,76 +232,76 @@ def build_microsimulation_options(self) -> dict:
             options["datasets"] = datasets
         elif self.country_id == "us":
             region = [
-                dict(name="us", label="the US", type="national"),
-                dict(name="state/al", label="Alabama", type="state"),
-                dict(name="state/ak", label="Alaska", type="state"),
-                dict(name="state/az", label="Arizona", type="state"),
-                dict(name="state/ar", label="Arkansas", type="state"),
-                dict(name="state/ca", label="California", type="state"),
-                dict(name="state/co", label="Colorado", type="state"),
-                dict(name="state/ct", label="Connecticut", type="state"),
-                dict(name="state/de", label="Delaware", type="state"),
-                dict(name="state/dc", label="District of Columbia", type="state"),
-                dict(name="state/fl", label="Florida", type="state"),
-                dict(name="state/ga", label="Georgia", type="state"),
-                dict(name="state/hi", label="Hawaii", type="state"),
-                dict(name="state/id", label="Idaho", type="state"),
-                dict(name="state/il", label="Illinois", type="state"),
-                dict(name="state/in", label="Indiana", type="state"),
-                dict(name="state/ia", label="Iowa", type="state"),
-                dict(name="state/ks", label="Kansas", type="state"),
-                dict(name="state/ky", label="Kentucky", type="state"),
-                dict(name="state/la", label="Louisiana", type="state"),
-                dict(name="state/me", label="Maine", type="state"),
-                dict(name="state/md", label="Maryland", type="state"),
-                dict(name="state/ma", label="Massachusetts", type="state"),
-                dict(name="state/mi", label="Michigan", type="state"),
-                dict(name="state/mn", label="Minnesota", type="state"),
-                dict(name="state/ms", label="Mississippi", type="state"),
-                dict(name="state/mo", label="Missouri", type="state"),
-                dict(name="state/mt", label="Montana", type="state"),
-                dict(name="state/ne", label="Nebraska", type="state"),
-                dict(name="state/nv", label="Nevada", type="state"),
-                dict(name="state/nh", label="New Hampshire", type="state"),
-                dict(name="state/nj", label="New Jersey", type="state"),
-                dict(name="state/nm", label="New Mexico", type="state"),
-                dict(name="state/ny", label="New York", type="state"),
-                dict(name="state/nc", label="North Carolina", type="state"),
-                dict(name="state/nd", label="North Dakota", type="state"),
-                dict(name="state/oh", label="Ohio", type="state"),
-                dict(name="state/ok", label="Oklahoma", type="state"),
-                dict(name="state/or", label="Oregon", type="state"),
-                dict(name="state/pa", label="Pennsylvania", type="state"),
-                dict(name="state/ri", label="Rhode Island", type="state"),
-                dict(name="state/sc", label="South Carolina", type="state"),
-                dict(name="state/sd", label="South Dakota", type="state"),
-                dict(name="state/tn", label="Tennessee", type="state"),
-                dict(name="state/tx", label="Texas", type="state"),
-                dict(name="state/ut", label="Utah", type="state"),
-                dict(name="state/vt", label="Vermont", type="state"),
-                dict(name="state/va", label="Virginia", type="state"),
-                dict(name="state/wa", label="Washington", type="state"),
-                dict(name="state/wv", label="West Virginia", type="state"),
-                dict(name="state/wi", label="Wisconsin", type="state"),
-                dict(name="state/wy", label="Wyoming", type="state"),
+                {"name": "us", "label": "the US", "type": "national"},
+                {"name": "state/al", "label": "Alabama", "type": "state"},
+                {"name": "state/ak", "label": "Alaska", "type": "state"},
+                {"name": "state/az", "label": "Arizona", "type": "state"},
+                {"name": "state/ar", "label": "Arkansas", "type": "state"},
+                {"name": "state/ca", "label": "California", "type": "state"},
+                {"name": "state/co", "label": "Colorado", "type": "state"},
+                {"name": "state/ct", "label": "Connecticut", "type": "state"},
+                {"name": "state/de", "label": "Delaware", "type": "state"},
+                {"name": "state/dc", "label": "District of Columbia", "type": "state"},
+                {"name": "state/fl", "label": "Florida", "type": "state"},
+                {"name": "state/ga", "label": "Georgia", "type": "state"},
+                {"name": "state/hi", "label": "Hawaii", "type": "state"},
+                {"name": "state/id", "label": "Idaho", "type": "state"},
+                {"name": "state/il", "label": "Illinois", "type": "state"},
+                {"name": "state/in", "label": "Indiana", "type": "state"},
+                {"name": "state/ia", "label": "Iowa", "type": "state"},
+                {"name": "state/ks", "label": "Kansas", "type": "state"},
+                {"name": "state/ky", "label": "Kentucky", "type": "state"},
+                {"name": "state/la", "label": "Louisiana", "type": "state"},
+                {"name": "state/me", "label": "Maine", "type": "state"},
+                {"name": "state/md", "label": "Maryland", "type": "state"},
+                {"name": "state/ma", "label": "Massachusetts", "type": "state"},
+                {"name": "state/mi", "label": "Michigan", "type": "state"},
+                {"name": "state/mn", "label": "Minnesota", "type": "state"},
+                {"name": "state/ms", "label": "Mississippi", "type": "state"},
+                {"name": "state/mo", "label": "Missouri", "type": "state"},
+                {"name": "state/mt", "label": "Montana", "type": "state"},
+                {"name": "state/ne", "label": "Nebraska", "type": "state"},
+                {"name": "state/nv", "label": "Nevada", "type": "state"},
+                {"name": "state/nh", "label": "New Hampshire", "type": "state"},
+                {"name": "state/nj", "label": "New Jersey", "type": "state"},
+                {"name": "state/nm", "label": "New Mexico", "type": "state"},
+                {"name": "state/ny", "label": "New York", "type": "state"},
+                {"name": "state/nc", "label": "North Carolina", "type": "state"},
+                {"name": "state/nd", "label": "North Dakota", "type": "state"},
+                {"name": "state/oh", "label": "Ohio", "type": "state"},
+                {"name": "state/ok", "label": "Oklahoma", "type": "state"},
+                {"name": "state/or", "label": "Oregon", "type": "state"},
+                {"name": "state/pa", "label": "Pennsylvania", "type": "state"},
+                {"name": "state/ri", "label": "Rhode Island", "type": "state"},
+                {"name": "state/sc", "label": "South Carolina", "type": "state"},
+                {"name": "state/sd", "label": "South Dakota", "type": "state"},
+                {"name": "state/tn", "label": "Tennessee", "type": "state"},
+                {"name": "state/tx", "label": "Texas", "type": "state"},
+                {"name": "state/ut", "label": "Utah", "type": "state"},
+                {"name": "state/vt", "label": "Vermont", "type": "state"},
+                {"name": "state/va", "label": "Virginia", "type": "state"},
+                {"name": "state/wa", "label": "Washington", "type": "state"},
+                {"name": "state/wv", "label": "West Virginia", "type": "state"},
+                {"name": "state/wi", "label": "Wisconsin", "type": "state"},
+                {"name": "state/wy", "label": "Wyoming", "type": "state"},
             ]
             # Add all 436 congressional districts (435 voting + DC)
             region.extend(build_congressional_district_metadata())
             time_period = [
-                dict(name=2035, label="2035"),
-                dict(name=2034, label="2034"),
-                dict(name=2033, label="2033"),
-                dict(name=2032, label="2032"),
-                dict(name=2031, label="2031"),
-                dict(name=2030, label="2030"),
-                dict(name=2029, label="2029"),
-                dict(name=2028, label="2028"),
-                dict(name=2027, label="2027"),
-                dict(name=2026, label="2026"),
-                dict(name=2025, label="2025"),
-                dict(name=2024, label="2024"),
-                dict(name=2023, label="2023"),
-                dict(name=2022, label="2022"),
+                {"name": 2035, "label": "2035"},
+                {"name": 2034, "label": "2034"},
+                {"name": 2033, "label": "2033"},
+                {"name": 2032, "label": "2032"},
+                {"name": 2031, "label": "2031"},
+                {"name": 2030, "label": "2030"},
+                {"name": 2029, "label": "2029"},
+                {"name": 2028, "label": "2028"},
+                {"name": 2027, "label": "2027"},
+                {"name": 2026, "label": "2026"},
+                {"name": 2025, "label": "2025"},
+                {"name": 2024, "label": "2024"},
+                {"name": 2023, "label": "2023"},
+                {"name": 2022, "label": "2022"},
             ]
             datasets = [get_bundle_default_dataset_option("us")]
             options["region"] = region
@@ -308,10 +309,10 @@ def build_microsimulation_options(self) -> dict:
             options["datasets"] = datasets
         elif self.country_id == "ca":
             region = [
-                dict(name="ca", label="Canada"),
+                {"name": "ca", "label": "Canada"},
             ]
             time_period = [
-                dict(name=2023, label="2023"),
+                {"name": 2023, "label": "2023"},
             ]
             datasets = [{}]
             options["region"] = region
@@ -319,10 +320,10 @@ def build_microsimulation_options(self) -> dict:
             options["datasets"] = datasets
         elif self.country_id == "ng":
             region = [
-                dict(name="ng", label="Nigeria"),
+                {"name": "ng", "label": "Nigeria"},
             ]
             time_period = [
-                dict(name=2023, label="2023"),
+                {"name": 2023, "label": "2023"},
             ]
             datasets = [{}]
             options["region"] = region
@@ -330,10 +331,10 @@ def build_microsimulation_options(self) -> dict:
             options["datasets"] = datasets
         elif self.country_id == "il":
             region = [
-                dict(name="il", label="Israel"),
+                {"name": "il", "label": "Israel"},
             ]
             time_period = [
-                dict(name=2023, label="2023"),
+                {"name": 2023, "label": "2023"},
             ]
             datasets = [{}]
             options["region"] = region
@@ -369,7 +370,7 @@ def build_variables(self) -> dict:
             }
             if variable.value_type.__name__ == "Enum":
                 variable_data[variable_name]["possibleValues"] = [
-                    dict(value=value.name, label=value.value)
+                    {"value": value.name, "label": value.value}
                     for value in variable.possible_values
                 ]
                 variable_data[variable_name]["defaultValue"] = (
@@ -382,7 +383,7 @@ def build_parameters(self) -> dict:
         parameters = self.tax_benefit_system.parameters
         parameter_data = {}
         for parameter in parameters.get_descendants():
-            if "gov" != parameter.name[:3]:
+            if parameter.name[:3] != "gov":
                 continue
             end_name = parameter.name.split(".")[-1]
             if isinstance(parameter, ParameterScale):
@@ -468,6 +469,7 @@ def calculate(
         household: dict,
         reform: dict | None,
         spm: dict | None = None,
+        *,
         spm_requested: bool = False,
         prepared: PreparedCountryCalculation | None = None,
     ) -> CalculationResult:
@@ -506,7 +508,7 @@ def calculate(
                 if has_axes:
                     count_entities = len(household[entity_plural])
                     entity_index = 0
-                    for _entity_id in household[entity_plural].keys():
+                    for _entity_id in household[entity_plural]:
                         if _entity_id == entity_id:
                             break
                         entity_index += 1
@@ -566,6 +568,7 @@ def prepare_calculation(
         household: dict,
         reform: dict | None,
         spm: dict | None = None,
+        *,
         spm_requested: bool = False,
     ) -> PreparedCountryCalculation:
         """Parse a situation before the API accepts it as a calculation."""
@@ -635,11 +638,12 @@ def _normalize_reform_values(
                 node_type = type(parameter.values_list[-1].value)
                 if node_type is int:
                     node_type = float
-                try:
-                    value = float(value)
-                except (TypeError, ValueError, OverflowError):
-                    pass
-                normalized_reform[parameter_name][time_period] = node_type(value)
+                numeric_value = value
+                with contextlib.suppress(TypeError, ValueError, OverflowError):
+                    numeric_value = float(value)
+                normalized_reform[parameter_name][time_period] = node_type(
+                    numeric_value
+                )
         return normalized_reform
 
     def _apply_reform_to_system(
@@ -674,9 +678,9 @@ def modify_parameters(parameters: ParameterNode) -> ParameterNode:
             node = parameters
             for step in path.split("."):
                 if "[" in step:
-                    step, index = step.split("[")
+                    child_name, index = step.split("[")
                     index = int(index[:-1])
-                    node = node.children[step].brackets[index]
+                    node = node.children[child_name].brackets[index]
                 else:
                     node = node.children[step]
             for period, value in values.items():
diff --git a/policyengine_api/data/congressional_districts.py b/policyengine_api/data/congressional_districts.py
index 5c6603260..7f38f0e1d 100644
--- a/policyengine_api/data/congressional_districts.py
+++ b/policyengine_api/data/congressional_districts.py
@@ -699,7 +699,7 @@ def get_valid_state_codes() -> set[str]:
         Set of 51 lowercase state codes (50 states + DC)
 
     """
-    return {code.lower() for code in STATE_CODE_TO_NAME.keys()}
+    return {code.lower() for code in STATE_CODE_TO_NAME}
 
 
 def get_valid_congressional_districts() -> set[str]:
diff --git a/policyengine_api/data/orm.py b/policyengine_api/data/orm.py
index 12e9a5ec2..6f3e8a4c2 100644
--- a/policyengine_api/data/orm.py
+++ b/policyengine_api/data/orm.py
@@ -49,7 +49,7 @@ def build_session_factory(engine: Engine) -> sessionmaker[Session]:
 
 
 def _build_remote_engine() -> Engine:
-    global _cloud_sql_connector
+    global _cloud_sql_connector  # noqa: PLW0603  # process-owned Cloud SQL state, created lazily and released by close_v1_engines
     config = get_remote_database_config()
     connector = Connector(
         ip_type=CLOUD_SQL_IP_TYPE,
@@ -81,7 +81,7 @@ def get_connection() -> DBAPIConnection:
 
 def get_v1_engine() -> Engine:
     """Return the process-owned Cloud SQL engine; never select SQLite."""
-    global _v1_engine
+    global _v1_engine  # noqa: PLW0603  # process-owned Cloud SQL state, created lazily and released by close_v1_engines
     if _v1_engine is None:
         _v1_engine = _build_remote_engine()
     return _v1_engine
@@ -89,7 +89,7 @@ def get_v1_engine() -> Engine:
 
 def get_v1_session_factory() -> sessionmaker[Session]:
     """Return one configured Session factory for the Cloud SQL engine."""
-    global _v1_session_factory
+    global _v1_session_factory  # noqa: PLW0603  # process-owned Cloud SQL state, created lazily and released by close_v1_engines
     if _v1_session_factory is None:
         _v1_session_factory = build_session_factory(get_v1_engine())
     return _v1_session_factory
@@ -97,13 +97,13 @@ def get_v1_session_factory() -> sessionmaker[Session]:
 
 def clear_v1_session_factories() -> None:
     """Forget cached factories, primarily after replacing an Engine in tests."""
-    global _v1_session_factory
+    global _v1_session_factory  # noqa: PLW0603  # process-owned Cloud SQL state, created lazily and released by close_v1_engines
     _v1_session_factory = None
 
 
 def close_v1_engines() -> None:
     """Release process-owned SQLAlchemy pools and Cloud SQL connectors."""
-    global _cloud_sql_connector, _v1_engine
+    global _cloud_sql_connector, _v1_engine  # noqa: PLW0603  # process-owned Cloud SQL state, created lazily and released by close_v1_engines
     clear_v1_session_factories()
     if _v1_engine is not None:
         _v1_engine.dispose()
diff --git a/policyengine_api/data/v2/catalog/extraction.py b/policyengine_api/data/v2/catalog/extraction.py
index 1a09f2abb..a21e8f7cc 100644
--- a/policyengine_api/data/v2/catalog/extraction.py
+++ b/policyengine_api/data/v2/catalog/extraction.py
@@ -611,7 +611,7 @@ def _normalize_country(
 
     regions: list[RegionRecord] = []
     for source_region in source_regions:
-        code = str(getattr(source_region, "code"))
+        code = str(source_region.code)
         strategy = getattr(source_region, "scoping_strategy", None)
         requires_filter = bool(getattr(source_region, "requires_filter", False))
         if requires_filter:
@@ -649,7 +649,7 @@ def _normalize_country(
                     field_name=f"region {code} label",
                     maximum=255,
                 ),
-                region_type=str(getattr(source_region, "region_type")),
+                region_type=str(source_region.region_type),
                 requires_filter=requires_filter,
                 filter_field=filter_field,
                 filter_value=filter_value,
diff --git a/policyengine_api/data/v2/catalog/publication_reconciliation.py b/policyengine_api/data/v2/catalog/publication_reconciliation.py
index 98872c630..0977676c6 100644
--- a/policyengine_api/data/v2/catalog/publication_reconciliation.py
+++ b/policyengine_api/data/v2/catalog/publication_reconciliation.py
@@ -201,7 +201,7 @@ def _comparison_pairs(
         STAGE_CATALOG_DATASETS.c.name,
         STAGE_CATALOG_DATASETS.c.description,
         STAGE_CATALOG_DATASETS.c.year,
-        sa.literal(False),
+        sa.literal(value=False),
         sa.cast(sa.null(), DATASETS.c.storage_path.type),
     ).where(STAGE_CATALOG_DATASETS.c.country_id == country.country_id)
     actual_datasets = (
@@ -362,7 +362,7 @@ def assert_country_matches(
         STAGE_CATALOG_DATASETS.c.description,
         sa.cast(sa.null(), DATASETS.c.storage_path.type),
         STAGE_CATALOG_DATASETS.c.year,
-        sa.literal(False),
+        sa.literal(value=False),
         MODEL_VERSIONS.c.id,
     )
     .select_from(
diff --git a/policyengine_api/data/v2/catalog/publication_staging.py b/policyengine_api/data/v2/catalog/publication_staging.py
index cd9b4675d..7f991b25a 100644
--- a/policyengine_api/data/v2/catalog/publication_staging.py
+++ b/policyengine_api/data/v2/catalog/publication_staging.py
@@ -281,11 +281,10 @@ def copy_rows(
         sql.SQL(", ").join(sql.Identifier(column.name) for column in table.columns),
     )
     count = 0
-    with raw_connection.cursor() as cursor:
-        with cursor.copy(statement) as copy:
-            for row in rows:
-                copy.write_row(row)
-                count += 1
+    with raw_connection.cursor() as cursor, cursor.copy(statement) as copy:
+        for row in rows:
+            copy.write_row(row)
+            count += 1
     return count
 
 
diff --git a/policyengine_api/data/v2/database.py b/policyengine_api/data/v2/database.py
index c5e7b5d0f..44dedf2c7 100644
--- a/policyengine_api/data/v2/database.py
+++ b/policyengine_api/data/v2/database.py
@@ -70,7 +70,7 @@ def build_v2_session_factory(engine: Engine) -> sessionmaker[Session]:
 
 def _discard_inherited_state(current_pid: int) -> None:
     """Drop pool state inherited through a process fork without touching parent FDs."""
-    global _engine, _engine_pid, _engine_url_fingerprint, _session_factory
+    global _engine, _engine_pid, _engine_url_fingerprint, _session_factory  # noqa: PLW0603  # process-owned v2 engine state, guarded by _state_lock and reset after a fork
 
     if _engine is not None:
         _engine.dispose(close=False)
@@ -82,7 +82,7 @@ def _discard_inherited_state(current_pid: int) -> None:
 
 def get_v2_engine(settings: V2DatabaseSettings | None = None) -> Engine:
     """Return the one lazy v2 runtime engine owned by this process."""
-    global _engine, _engine_pid, _engine_url_fingerprint
+    global _engine, _engine_pid, _engine_url_fingerprint  # noqa: PLW0603  # process-owned v2 engine state, guarded by _state_lock and reset after a fork
 
     current_pid = os.getpid()
     with _state_lock:
@@ -110,7 +110,7 @@ def get_v2_session_factory(
     settings: V2DatabaseSettings | None = None,
 ) -> sessionmaker[Session]:
     """Return the process-owned SQLModel Session factory without opening a session."""
-    global _session_factory
+    global _session_factory  # noqa: PLW0603  # process-owned v2 engine state, guarded by _state_lock and reset after a fork
 
     engine = get_v2_engine(settings)
     with _state_lock:
@@ -121,7 +121,7 @@ def get_v2_session_factory(
 
 def close_v2_database() -> None:
     """Dispose this process's v2 pool and forget its lazy configuration."""
-    global _engine, _engine_pid, _engine_url_fingerprint, _session_factory
+    global _engine, _engine_pid, _engine_url_fingerprint, _session_factory  # noqa: PLW0603  # process-owned v2 engine state, guarded by _state_lock and reset after a fork
 
     with _state_lock:
         if _engine is not None:
diff --git a/policyengine_api/data/v2/models/__init__.py b/policyengine_api/data/v2/models/__init__.py
index b8c7ed386..c63655bb6 100644
--- a/policyengine_api/data/v2/models/__init__.py
+++ b/policyengine_api/data/v2/models/__init__.py
@@ -95,6 +95,7 @@
 validate_v2_metadata_table_names(V2_METADATA.tables)
 
 __all__ = [
+    "V2_METADATA",
     "AggregateOutput",
     "AggregateType",
     "BudgetSummary",
@@ -111,11 +112,11 @@
     "HouseholdJobStatus",
     "Inequality",
     "IntraDecileImpact",
-    "LocalAuthorityImpact",
-    "LegacyPolicyMapping",
     "LegacyHouseholdMapping",
+    "LegacyPolicyMapping",
     "LegacyUserMapping",
     "LegacyUserPolicyMapping",
+    "LocalAuthorityImpact",
     "OutputStatus",
     "Parameter",
     "ParameterNode",
@@ -147,6 +148,5 @@
     "UserReportAssociation",
     "UserSimulationAssociation",
     "UserType",
-    "V2_METADATA",
     "Variable",
 ]
diff --git a/policyengine_api/fastapi_routes/dependencies.py b/policyengine_api/fastapi_routes/dependencies.py
index 99dc73cc5..a23018978 100644
--- a/policyengine_api/fastapi_routes/dependencies.py
+++ b/policyengine_api/fastapi_routes/dependencies.py
@@ -5,7 +5,7 @@
 from dataclasses import dataclass
 from functools import lru_cache
 from importlib import metadata as importlib_metadata
-from typing import TYPE_CHECKING, Protocol
+from typing import TYPE_CHECKING, Annotated, Protocol
 
 from fastapi import Depends
 from fastapi.security import APIKeyHeader, HTTPAuthorizationCredentials, HTTPBearer
@@ -797,8 +797,10 @@ def _default_v2_household_service_factory() -> V2HouseholdResourceService:
 
 
 def _default_require_user(
-    credentials: HTTPAuthorizationCredentials | None = Depends(_user_bearer_scheme),
-    unauthenticated_user: str | None = Depends(_unauthenticated_user_scheme),
+    credentials: Annotated[
+        HTTPAuthorizationCredentials | None, Depends(_user_bearer_scheme)
+    ],
+    unauthenticated_user: Annotated[str | None, Depends(_unauthenticated_user_scheme)],
 ) -> AccountPrincipal:
     """Authenticate the request's account; fails closed without a credential."""
     return authenticate_account_request(
diff --git a/policyengine_api/fastapi_routes/v2/me/routes.py b/policyengine_api/fastapi_routes/v2/me/routes.py
index 3c64d0659..4b756209a 100644
--- a/policyengine_api/fastapi_routes/v2/me/routes.py
+++ b/policyengine_api/fastapi_routes/v2/me/routes.py
@@ -156,7 +156,7 @@ def patch() -> MeDetailResponse:
         ),
     )
     def delete_me(
-        query: CountryQueryDependency,
+        _query: CountryQueryDependency,
         principal: Annotated[AccountPrincipal, Depends(require_user)],
     ) -> Response | JSONResponse:
         def delete() -> Response:
diff --git a/policyengine_api/fastapi_routes/v2/metadata/common.py b/policyengine_api/fastapi_routes/v2/metadata/common.py
index 52eae3a80..fd4eaab5d 100644
--- a/policyengine_api/fastapi_routes/v2/metadata/common.py
+++ b/policyengine_api/fastapi_routes/v2/metadata/common.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 from typing import TYPE_CHECKING, Any, TypeVar
 
 from pydantic import BaseModel
@@ -100,7 +101,6 @@ def read_resource(
         return v2_error_response(500, "V2 metadata query failed")
     finally:
         if reader is not None:
-            try:
+            # Best-effort close must not replace the typed response.
+            with contextlib.suppress(Exception):
                 reader.close()
-            except Exception:  # noqa: BLE001, S110  # best-effort close must not replace the typed response
-                pass
diff --git a/policyengine_api/fastapi_routes/v2/metadata/parameter_routes.py b/policyengine_api/fastapi_routes/v2/metadata/parameter_routes.py
index dfe11f152..2ed036387 100644
--- a/policyengine_api/fastapi_routes/v2/metadata/parameter_routes.py
+++ b/policyengine_api/fastapi_routes/v2/metadata/parameter_routes.py
@@ -114,7 +114,7 @@ def list_parameter_values(
         country_id: str,
         policyengine_version: str | None = None,
         parameter_id: UUID | None = None,
-        current: bool = False,
+        current: bool = False,  # noqa: FBT001, FBT002  # FastAPI query parameter
         offset: Offset = 0,
         limit: Limit = 100,
     ) -> MetadataParameterValuePageResponse | JSONResponse:
diff --git a/policyengine_api/libs/simulation_api.py b/policyengine_api/libs/simulation_api.py
index a3aa22d15..94a274f8e 100644
--- a/policyengine_api/libs/simulation_api.py
+++ b/policyengine_api/libs/simulation_api.py
@@ -20,8 +20,8 @@
     "ModalBudgetWindowBatchExecution",
     "ModalSimulationExecution",
     "SimulationAPIClient",
-    "SimulationEntrypointClient",
     "SimulationAPIModal",
+    "SimulationEntrypointClient",
     "resolve_simulation_api_url",
     "resolve_simulation_entrypoint_url",
     "simulation_api",
diff --git a/policyengine_api/libs/simulation_api_modal.py b/policyengine_api/libs/simulation_api_modal.py
index 2c472af46..72a8c0822 100644
--- a/policyengine_api/libs/simulation_api_modal.py
+++ b/policyengine_api/libs/simulation_api_modal.py
@@ -17,8 +17,8 @@
     "ModalBudgetWindowBatchExecution",
     "ModalSimulationExecution",
     "SimulationAPIClient",
-    "SimulationEntrypointClient",
     "SimulationAPIModal",
+    "SimulationEntrypointClient",
     "resolve_simulation_api_url",
     "resolve_simulation_entrypoint_url",
     "simulation_api",
diff --git a/policyengine_api/libs/simulation_entrypoint.py b/policyengine_api/libs/simulation_entrypoint.py
index c083615e2..4c8e9c2b4 100644
--- a/policyengine_api/libs/simulation_entrypoint.py
+++ b/policyengine_api/libs/simulation_entrypoint.py
@@ -356,7 +356,7 @@ def run(self, payload: dict) -> ModalSimulationExecution:
         except httpx.RequestError as e:
             logger.log_struct(
                 {
-                    "message": f"Simulation entrypoint request error: {str(e)}",
+                    "message": f"Simulation entrypoint request error: {e!s}",
                     "observability_id": current_observability_id(),
                 },
                 severity="ERROR",
@@ -405,7 +405,7 @@ def run_budget_window_batch(self, payload: dict) -> ModalBudgetWindowBatchExecut
         except httpx.RequestError as e:
             logger.log_struct(
                 {
-                    "message": f"Simulation batch API request error: {str(e)}",
+                    "message": f"Simulation batch API request error: {e!s}",
                     "observability_id": current_observability_id(),
                 },
                 severity="ERROR",
@@ -545,7 +545,7 @@ def get_execution_by_id(self, job_id: str) -> ModalSimulationExecution:
                 {
                     "message": (
                         f"Simulation entrypoint request error polling job {job_id}: "
-                        f"{str(e)}"
+                        f"{e!s}"
                     ),
                 },
                 severity="ERROR",
@@ -595,7 +595,7 @@ def get_budget_window_batch_by_id(
                 {
                     "message": (
                         "Simulation batch API request error polling job "
-                        f"{batch_job_id}: {str(e)}"
+                        f"{batch_job_id}: {e!s}"
                     ),
                 },
                 severity="ERROR",
diff --git a/policyengine_api/migration_logging.py b/policyengine_api/migration_logging.py
index 969e3fa8d..76056303c 100644
--- a/policyengine_api/migration_logging.py
+++ b/policyengine_api/migration_logging.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from typing import TYPE_CHECKING
 
@@ -102,10 +103,9 @@ def set_request_migration_context() -> None:
         )
         flask.g.observability_id = None
         if runtime is not None:
-            try:
+            # Telemetry must never fail the request.
+            with contextlib.suppress(Exception):
                 runtime.set_context(request_id=flask.g.request_id)
-            except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-                pass
 
     @app.after_request
     def log_request_migration_context(response: flask.Response) -> flask.Response:
@@ -143,11 +143,10 @@ def log_request_migration_context(response: flask.Response) -> flask.Response:
                     country_id=country_id,
                     route_impl=RouteImplementation.FLASK_FALLBACK,
                 )
-        except Exception:  # noqa: BLE001  # logs the traceback below, guarded so logging cannot fail the response
-            try:
+        except Exception:
+            # A logging failure must not replace the response.
+            with contextlib.suppress(Exception):
                 app.logger.exception("Failed to log migration request context")
-            except Exception:  # noqa: BLE001, S110  # a logging failure must not replace the response
-                pass
         return response
 
 
diff --git a/policyengine_api/observability/runtime.py b/policyengine_api/observability/runtime.py
index 8662567f2..b01840b18 100644
--- a/policyengine_api/observability/runtime.py
+++ b/policyengine_api/observability/runtime.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import os
 from dataclasses import replace
 from importlib.metadata import PackageNotFoundError, version
@@ -74,7 +75,6 @@ def get_runtime() -> ObservabilityRuntime:
 
 def set_runtime_context(**attributes: object) -> None:
     """Bind local telemetry attributes without affecting application behavior."""
-    try:
+    # Telemetry must never affect application behavior.
+    with contextlib.suppress(Exception):
         runtime.set_context(**attributes)
-    except Exception:  # noqa: BLE001, S110  # telemetry must never affect application behavior
-        pass
diff --git a/policyengine_api/readiness.py b/policyengine_api/readiness.py
index f94255c82..d8dad66f6 100644
--- a/policyengine_api/readiness.py
+++ b/policyengine_api/readiness.py
@@ -52,14 +52,14 @@ def validate_policy_runtime_configuration() -> None:
 
 def mark_not_ready() -> None:
     """Report not-ready — call before running the startup warmup."""
-    global _ready
+    global _ready  # noqa: PLW0603  # process-wide readiness flag, guarded by _lock
     with _lock:
         _ready = False
 
 
 def mark_ready() -> None:
     """Report ready — call once the startup warmup has completed."""
-    global _ready
+    global _ready  # noqa: PLW0603  # process-wide readiness flag, guarded by _lock
     with _lock:
         _ready = True
 
diff --git a/policyengine_api/request_context.py b/policyengine_api/request_context.py
index e5e32f088..c487dd6de 100644
--- a/policyengine_api/request_context.py
+++ b/policyengine_api/request_context.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import uuid
 from contextvars import ContextVar
 
@@ -60,10 +61,9 @@ def _bind_observability_id(observability_id: str) -> str:
         flask.g.observability_id = observability_id
     else:
         _asgi_observability_id.set(observability_id)
-    try:
+    # Telemetry must never fail the request.
+    with contextlib.suppress(Exception):
         observability.get_runtime().set_context(observability_id=observability_id)
-    except Exception:  # noqa: BLE001, S110  # telemetry must never fail the request
-        pass
     return observability_id
 
 
diff --git a/policyengine_api/routes/household_routes.py b/policyengine_api/routes/household_routes.py
index 26e7b6df0..d2c7c9646 100644
--- a/policyengine_api/routes/household_routes.py
+++ b/policyengine_api/routes/household_routes.py
@@ -1,5 +1,6 @@
 """Flask routes for v1 households and calculations, with optional copying to API v2."""
 
+import contextlib
 import json
 import logging
 import time
@@ -90,7 +91,8 @@ def _household_persistence_failure(
     started_at: float,
 ) -> Response:
     status_code = 503 if error.retryable else 500
-    try:
+    # Metric logging must not replace the error response.
+    with contextlib.suppress(Exception):
         logger.log_struct(
             {
                 "message": "V1 household persistence failed",
@@ -109,8 +111,6 @@ def _household_persistence_failure(
             },
             severity="ERROR",
         )
-    except Exception:  # noqa: BLE001, S110  # metric logging must not replace the error response
-        pass
     message = (
         "Household database is temporarily unavailable; please try again later."
         if status_code == 503
@@ -145,9 +145,11 @@ def _spm_error_response(error: Exception) -> Response | None:
 
 
 def _calculation_response(calculation: HouseholdCalculationResult) -> dict:
-    result: dict[str, object] = dict(
-        status="ok", message=None, result=calculation.household
-    )
+    result: dict[str, object] = {
+        "status": "ok",
+        "message": None,
+        "result": calculation.household,
+    }
     if calculation.warnings:
         result["warnings"] = list(calculation.warnings)
     if calculation.spm_provenance is not None:
@@ -250,7 +252,7 @@ def wrapped(
     return decorator
 
 
-def _calculation_cache_key(*args: object, **kwargs: object) -> str:
+def _calculation_cache_key(*_args: object, **_kwargs: object) -> str:
     country_id = request.view_args["country_id"]
     return hash_object(
         {
@@ -493,7 +495,7 @@ def _calculate() -> dict | Response:
 @validate_country
 @_validate_calculation_request(add_missing=False)
 @cache.cached(make_cache_key=_calculation_cache_key)
-def get_calculate(country_id: str) -> dict | Response:
+def get_calculate(country_id: str) -> dict | Response:  # noqa: ARG001  # Flask passes the <country_id> URL variable by keyword
     """Calculate a household without adding omitted yearly variables."""
     return _calculate()
 
@@ -502,6 +504,6 @@ def get_calculate(country_id: str) -> dict | Response:
 @validate_country
 @_validate_calculation_request(add_missing=True)
 @cache.cached(make_cache_key=_calculation_cache_key)
-def get_calculate_full(country_id: str) -> dict | Response:
+def get_calculate_full(country_id: str) -> dict | Response:  # noqa: ARG001  # Flask passes the <country_id> URL variable by keyword
     """Calculate a household after adding omitted yearly variables."""
     return _calculate()
diff --git a/policyengine_api/routes/policy_routes.py b/policyengine_api/routes/policy_routes.py
index 524506bda..f63e03b3b 100644
--- a/policyengine_api/routes/policy_routes.py
+++ b/policyengine_api/routes/policy_routes.py
@@ -1,5 +1,6 @@
 """Flask routes for v1 policies and saved user policies, optionally mirrored to v2."""
 
+import contextlib
 import json
 import time
 
@@ -89,7 +90,8 @@ def _user_policy_persistence_failure(
 ) -> Response:
     """Return and record a failure without serializing exception details."""
     status_code = 503 if error.retryable else 500
-    try:
+    # A logging failure must not replace the persistence response.
+    with contextlib.suppress(Exception):
         logger.log_struct(
             {
                 "message": "V1 saved-policy persistence failed",
@@ -114,8 +116,6 @@ def _user_policy_persistence_failure(
             },
             severity="ERROR",
         )
-    except Exception:  # noqa: BLE001, S110  # a logging failure must not replace the persistence response
-        pass
 
     message = (
         "Policy database is temporarily unavailable; please try again later."
@@ -221,13 +221,13 @@ def set_policy(country_id: str) -> Response:
         except PolicyMirrorUnavailableError:
             return _policy_mirror_unavailable()
 
-    response_body = dict(
-        status="ok",
-        message=message,
-        result=dict(
-            policy_id=policy_id,
-        ),
-    )
+    response_body = {
+        "status": "ok",
+        "message": message,
+        "result": {
+            "policy_id": policy_id,
+        },
+    }
 
     code = 200 if is_existing_policy else 201
     return Response(json.dumps(response_body), status=code, mimetype="application/json")
@@ -265,14 +265,14 @@ def get_policy_search(country_id: str) -> Response:
                 404,
             )
 
-        policies = [dict(id=result.id, label=result.label) for result in results]
+        policies = [{"id": result.id, "label": result.label} for result in results]
         return Response(
             json.dumps(
-                dict(
-                    status="ok",
-                    message="Policies found",
-                    result=policies,
-                )
+                {
+                    "status": "ok",
+                    "message": "Policies found",
+                    "result": policies,
+                }
             ),
             status=200,
             mimetype="application/json",
@@ -365,14 +365,14 @@ def set_user_policy(country_id: str) -> Response:
     if not creation.created:
         return Response(
             json.dumps(
-                dict(
-                    status="ok",
-                    message=(
+                {
+                    "status": "ok",
+                    "message": (
                         f"The reform #{reform_id} / baseline #{baseline_id} pair "
                         f"already exists for user {user_id}"
                     ),
-                    result=dict(id=user_policy.id),
-                )
+                    "result": {"id": user_policy.id},
+                }
             ),
             status=200,
             mimetype="application/json",
@@ -380,11 +380,11 @@ def set_user_policy(country_id: str) -> Response:
 
     return Response(
         json.dumps(
-            dict(
-                status="ok",
-                message="Record created successfully",
-                result=_serialize_user_policy(user_policy),
-            )
+            {
+                "status": "ok",
+                "message": "Record created successfully",
+                "result": _serialize_user_policy(user_policy),
+            }
         ),
         status=201,
         mimetype="application/json",
@@ -400,11 +400,11 @@ def get_user_policy(country_id: str, user_id: str) -> dict | Response:
     except ValueError:
         return _policy_configuration_unavailable()
     user_policies = user_policy_service.list_user_policies(country_id, user_id)
-    return dict(
-        status="ok",
-        message=None,
-        result=[_serialize_user_policy(row) for row in user_policies],
-    )
+    return {
+        "status": "ok",
+        "message": None,
+        "result": [_serialize_user_policy(row) for row in user_policies],
+    }
 
 
 UPDATE_USER_POLICY_ALLOWED_FIELDS = USER_POLICY_MUTABLE_FIELDS
@@ -491,11 +491,11 @@ def update_user_policy(country_id: str) -> Response:
 
     return Response(
         json.dumps(
-            dict(
-                status="ok",
-                message="Record updated successfully",
-                result=dict(id=user_policy_id),
-            )
+            {
+                "status": "ok",
+                "message": "Record updated successfully",
+                "result": {"id": user_policy_id},
+            }
         ),
         status=200,
         mimetype="application/json",
diff --git a/policyengine_api/routes/report_output_routes.py b/policyengine_api/routes/report_output_routes.py
index d1c588fed..98cefed86 100644
--- a/policyengine_api/routes/report_output_routes.py
+++ b/policyengine_api/routes/report_output_routes.py
@@ -105,11 +105,11 @@ def create_report_output(country_id: str) -> Response:
         )
         status_code = 201 if creation.created else 200
 
-        response_body = dict(
-            status="ok",
-            message=message,
-            result=result,
-        )
+        response_body = {
+            "status": "ok",
+            "message": message,
+            "result": result,
+        }
 
         return Response(
             json.dumps(response_body),
@@ -126,7 +126,7 @@ def create_report_output(country_id: str) -> Response:
             "Bad request creating report output for country %s: %s", country_id, e
         )
         msg = f"Failed to create report output: {e}"
-        raise BadRequest(msg)
+        raise BadRequest(msg) from e
     except Exception:
         current_app.logger.exception(
             "Unexpected error creating report output for country %s", country_id
@@ -155,11 +155,11 @@ def get_report_output(country_id: str, report_id: int) -> Response:
         raise NotFound(msg)
     result = _serialize_v1_report_output(view)
 
-    response_body = dict(
-        status="ok",
-        message=None,
-        result=result,
-    )
+    response_body = {
+        "status": "ok",
+        "message": None,
+        "result": result,
+    }
 
     return Response(
         json.dumps(response_body),
@@ -223,11 +223,11 @@ def update_report_output(country_id: str) -> Response:
         )
         result = _serialize_v1_report_output(view)
 
-        response_body = dict(
-            status="ok",
-            message="Report output updated successfully",
-            result=result,
-        )
+        response_body = {
+            "status": "ok",
+            "message": "Report output updated successfully",
+            "result": result,
+        }
 
         return Response(
             json.dumps(response_body),
@@ -250,7 +250,7 @@ def update_report_output(country_id: str) -> Response:
             e,
         )
         msg = f"Failed to update report output: {e}"
-        raise BadRequest(msg)
+        raise BadRequest(msg) from e
     except Exception:
         current_app.logger.exception(
             "Unexpected error updating report #%s for country %s",
diff --git a/policyengine_api/routes/simulation_routes.py b/policyengine_api/routes/simulation_routes.py
index d3d127d9e..0c74ab322 100644
--- a/policyengine_api/routes/simulation_routes.py
+++ b/policyengine_api/routes/simulation_routes.py
@@ -115,11 +115,11 @@ def create_simulation(country_id: str) -> Response:
         )
         status_code = 201 if creation.created else 200
 
-        response_body = dict(
-            status="ok",
-            message=message,
-            result=result,
-        )
+        response_body = {
+            "status": "ok",
+            "message": message,
+            "result": result,
+        }
 
         return Response(
             json.dumps(response_body),
@@ -136,7 +136,7 @@ def create_simulation(country_id: str) -> Response:
             "Bad request creating simulation for country %s: %s", country_id, e
         )
         msg = f"Failed to create simulation: {e}"
-        raise BadRequest(msg)
+        raise BadRequest(msg) from e
     except Exception:
         current_app.logger.exception(
             "Unexpected error creating simulation for country %s", country_id
@@ -168,11 +168,11 @@ def get_simulation(country_id: str, simulation_id: int) -> Response:
         msg = f"Simulation #{simulation_id} not found."
         raise NotFound(msg)
 
-    response_body = dict(
-        status="ok",
-        message=None,
-        result=result,
-    )
+    response_body = {
+        "status": "ok",
+        "message": None,
+        "result": result,
+    }
 
     return Response(
         json.dumps(response_body),
@@ -234,11 +234,11 @@ def update_simulation(country_id: str) -> Response:
 
         result = _serialize_v1_simulation(simulation)
 
-        response_body = dict(
-            status="ok",
-            message="Simulation updated successfully",
-            result=result,
-        )
+        response_body = {
+            "status": "ok",
+            "message": "Simulation updated successfully",
+            "result": result,
+        }
 
         return Response(
             json.dumps(response_body),
@@ -261,7 +261,7 @@ def update_simulation(country_id: str) -> Response:
             e,
         )
         msg = f"Failed to update simulation: {e}"
-        raise BadRequest(msg)
+        raise BadRequest(msg) from e
     except Exception:
         current_app.logger.exception(
             "Unexpected error updating simulation #%s for country %s",
diff --git a/policyengine_api/routes/user_profile_routes.py b/policyengine_api/routes/user_profile_routes.py
index 3cc175b5b..59ff29f85 100644
--- a/policyengine_api/routes/user_profile_routes.py
+++ b/policyengine_api/routes/user_profile_routes.py
@@ -54,11 +54,11 @@ def set_user_profile(country_id: str) -> Response:
     )
     result = _serialize_user_profile(profile, include_auth0_id=False)
 
-    response = dict(
-        status="ok",
-        message="Record created successfully" if created else "Record exists",
-        result=result,
-    )
+    response = {
+        "status": "ok",
+        "message": "Record created successfully" if created else "Record exists",
+        "result": result,
+    }
     return Response(
         json.dumps(response),
         status=201 if created else 200,
@@ -68,7 +68,7 @@ def set_user_profile(country_id: str) -> Response:
 
 @user_profile_bp.route("/<country_id>/user-profile", methods=["GET"])
 @validate_country
-def get_user_profile(country_id: str) -> Response:
+def get_user_profile(country_id: str) -> Response:  # noqa: ARG001  # Flask passes the <country_id> URL variable by keyword
     """Return a user profile looked up by ``auth0_id`` or, failing that, ``user_id``.
 
     The Auth0 ID is included only when the caller looked the profile up by it.
@@ -99,11 +99,11 @@ def get_user_profile(country_id: str) -> Response:
         msg = "No such user"
         raise NotFound(msg)
 
-    response_body = dict(
-        status="ok",
-        message=f"User #{readable_row['user_id']} found successfully",
-        result=readable_row,
-    )
+    response_body = {
+        "status": "ok",
+        "message": f"User #{readable_row['user_id']} found successfully",
+        "result": readable_row,
+    }
 
     return Response(
         json.dumps(response_body),
@@ -114,7 +114,7 @@ def get_user_profile(country_id: str) -> Response:
 
 @user_profile_bp.route("/<country_id>/user-profile", methods=["PUT"])
 @validate_country
-def update_user_profile(country_id: str) -> Response:
+def update_user_profile(country_id: str) -> Response:  # noqa: ARG001  # Flask passes the <country_id> URL variable by keyword
     """Update the username, primary country or start date of profile ``user_id``.
 
     The Auth0 ID cannot be changed: an ``auth0_id`` in the payload is ignored.
@@ -149,11 +149,11 @@ def update_user_profile(country_id: str) -> Response:
         msg = "No such user id"
         raise NotFound(msg)
 
-    response_body = dict(
-        status="ok",
-        message=f"User profile #{user_id} updated successfully",
-        result=dict(user_id=user_id),
-    )
+    response_body = {
+        "status": "ok",
+        "message": f"User profile #{user_id} updated successfully",
+        "result": {"user_id": user_id},
+    }
 
     return Response(
         json.dumps(response_body),
diff --git a/policyengine_api/runtime_cache/core.py b/policyengine_api/runtime_cache/core.py
index 5c1540f43..229c4ad7f 100644
--- a/policyengine_api/runtime_cache/core.py
+++ b/policyengine_api/runtime_cache/core.py
@@ -73,7 +73,7 @@ def delete(self, *keys: str) -> object:
         """Delete every given key and return how many existed."""
         ...
 
-    def pipeline(self, transaction: bool = True) -> CachePipeline:
+    def pipeline(self, *, transaction: bool = True) -> CachePipeline:
         """Return a pipeline whose commands run together on ``execute``."""
         ...
 
diff --git a/policyengine_api/runtime_cache/fake.py b/policyengine_api/runtime_cache/fake.py
index af842d4b0..0cb1e8a07 100644
--- a/policyengine_api/runtime_cache/fake.py
+++ b/policyengine_api/runtime_cache/fake.py
@@ -162,7 +162,7 @@ def eval(
                 return 0
             return self.delete(key)
 
-    def pipeline(self, transaction: bool = True) -> InMemoryPipeline:
+    def pipeline(self, *, transaction: bool = True) -> InMemoryPipeline:
         """Return a pipeline that queues commands until ``execute``."""
         return InMemoryPipeline(self, transaction=transaction)
 
@@ -215,39 +215,39 @@ class DisabledCacheBackend(InMemoryCacheBackend):
     def get(self, key: str) -> None:
         """Return None: every read is a miss."""
 
-    def set(self, key: str, value: str, **kwargs: object) -> bool:
+    def set(self, key: str, value: str, **_kwargs: object) -> bool:  # noqa: ARG002  # overrides InMemoryCacheBackend.set
         """Discard the value and report the write as not stored."""
         return False
 
-    def delete(self, *keys: str) -> int:
+    def delete(self, *_keys: str) -> int:
         """Return 0: no key ever exists."""
         return 0
 
-    def zadd(self, key: str, mapping: dict[str, float]) -> int:
+    def zadd(self, key: str, mapping: dict[str, float]) -> int:  # noqa: ARG002  # overrides InMemoryCacheBackend.zadd
         """Discard the members and report none added."""
         return 0
 
-    def zrevrange(self, key: str, start: int, end: int) -> list[str]:
+    def zrevrange(self, key: str, start: int, end: int) -> list[str]:  # noqa: ARG002  # overrides InMemoryCacheBackend.zrevrange
         """Return an empty list: no sorted set ever exists."""
         return []
 
-    def zrem(self, key: str, *members: str) -> int:
+    def zrem(self, key: str, *_members: str) -> int:  # noqa: ARG002  # overrides InMemoryCacheBackend.zrem
         """Return 0: there is nothing to remove."""
         return 0
 
-    def zremrangebyrank(self, key: str, start: int, end: int) -> int:
+    def zremrangebyrank(self, key: str, start: int, end: int) -> int:  # noqa: ARG002  # overrides InMemoryCacheBackend.zremrangebyrank
         """Return 0: there is nothing to remove."""
         return 0
 
-    def expire(self, key: str, seconds: int) -> bool:
+    def expire(self, key: str, seconds: int) -> bool:  # noqa: ARG002  # overrides InMemoryCacheBackend.expire
         """Return False, as Redis does for a key that does not exist."""
         return False
 
     def eval(
         self,
         _script: str,
-        numkeys: int,
-        *keys_and_args: str,
+        numkeys: int,  # noqa: ARG002  # overrides InMemoryCacheBackend.eval
+        *_keys_and_args: str,
     ) -> int:
         """Raise RuntimeError, so claim operations fail closed when disabled."""
         msg = "the shared runtime cache is disabled"
diff --git a/policyengine_api/services/economy_comparison.py b/policyengine_api/services/economy_comparison.py
index eccf99f22..2b917cd72 100644
--- a/policyengine_api/services/economy_comparison.py
+++ b/policyengine_api/services/economy_comparison.py
@@ -22,14 +22,14 @@ def budgetary_impact(baseline: dict, reform: dict) -> dict:
     state_tax_revenue_impact = reform["total_state_tax"] - baseline["total_state_tax"]
     benefit_spending_impact = reform["total_benefits"] - baseline["total_benefits"]
     budgetary_impact = tax_revenue_impact - benefit_spending_impact
-    return dict(
-        budgetary_impact=budgetary_impact,
-        tax_revenue_impact=tax_revenue_impact,
-        state_tax_revenue_impact=state_tax_revenue_impact,
-        benefit_spending_impact=benefit_spending_impact,
-        households=sum(baseline["household_weight"]),
-        baseline_net_income=baseline["total_net_income"],
-    )
+    return {
+        "budgetary_impact": budgetary_impact,
+        "tax_revenue_impact": tax_revenue_impact,
+        "state_tax_revenue_impact": state_tax_revenue_impact,
+        "benefit_spending_impact": benefit_spending_impact,
+        "households": sum(baseline["household_weight"]),
+        "baseline_net_income": baseline["total_net_income"],
+    }
 
 
 def labor_supply_response(baseline: dict, reform: dict) -> dict:
@@ -63,56 +63,58 @@ def labor_supply_response(baseline: dict, reform: dict) -> dict:
     substitution_lsr_hh = MicroSeries(substitution_lsr_hh, weights=household_weight)
     income_lsr_hh = MicroSeries(income_lsr_hh, weights=household_weight)
 
-    decile_avg = dict(
-        income=income_lsr_hh.groupby(decile).mean().to_dict(),
-        substitution=substitution_lsr_hh.groupby(decile).mean().to_dict(),
-    )
-    decile_rel = dict(
-        income=(
+    decile_avg = {
+        "income": income_lsr_hh.groupby(decile).mean().to_dict(),
+        "substitution": substitution_lsr_hh.groupby(decile).mean().to_dict(),
+    }
+    decile_rel = {
+        "income": (
             income_lsr_hh.groupby(decile).sum()
             / original_earnings.groupby(decile).sum()
         ).to_dict(),
-        substitution=(
+        "substitution": (
             substitution_lsr_hh.groupby(decile).sum()
             / original_earnings.groupby(decile).sum()
         ).to_dict(),
-    )
+    }
 
-    relative_lsr = dict(
-        income=(income_lsr_hh.sum() / original_earnings.sum()),
-        substitution=(substitution_lsr_hh.sum() / original_earnings.sum()),
-    )
+    relative_lsr = {
+        "income": (income_lsr_hh.sum() / original_earnings.sum()),
+        "substitution": (substitution_lsr_hh.sum() / original_earnings.sum()),
+    }
 
     decile_rel["income"] = {int(k): v for k, v in decile_rel["income"].items() if k > 0}
     decile_rel["substitution"] = {
         int(k): v for k, v in decile_rel["substitution"].items() if k > 0
     }
 
-    hours = dict(
-        baseline=baseline["weekly_hours"],
-        reform=reform["weekly_hours"],
-        change=reform["weekly_hours"] - baseline["weekly_hours"],
-        income_effect=reform["weekly_hours_income_effect"]
+    hours = {
+        "baseline": baseline["weekly_hours"],
+        "reform": reform["weekly_hours"],
+        "change": reform["weekly_hours"] - baseline["weekly_hours"],
+        "income_effect": reform["weekly_hours_income_effect"]
         - baseline["weekly_hours_income_effect"],
-        substitution_effect=reform["weekly_hours_substitution_effect"]
+        "substitution_effect": reform["weekly_hours_substitution_effect"]
         - baseline["weekly_hours_substitution_effect"],
-    )
+    }
 
-    return dict(
-        substitution_lsr=substitution_lsr,
-        income_lsr=income_lsr,
-        relative_lsr=relative_lsr,
-        total_change=total_change,
-        revenue_change=revenue_change,
-        decile=dict(
-            average=decile_avg,
-            relative=decile_rel,
-        ),
-        hours=hours,
-    )
+    return {
+        "substitution_lsr": substitution_lsr,
+        "income_lsr": income_lsr,
+        "relative_lsr": relative_lsr,
+        "total_change": total_change,
+        "revenue_change": revenue_change,
+        "decile": {
+            "average": decile_avg,
+            "relative": decile_rel,
+        },
+        "hours": hours,
+    }
 
 
-def detailed_budgetary_impact(baseline: dict, reform: dict, country_id: str) -> dict:
+def detailed_budgetary_impact(
+    baseline: dict, reform: dict, country_id: str | None
+) -> dict:
     """Return baseline, reform and difference for each UK programme's budget.
 
     Only the UK reports programme-level totals; other countries get an empty dict.
@@ -121,11 +123,12 @@ def detailed_budgetary_impact(baseline: dict, reform: dict, country_id: str) ->
     if country_id == "uk":
         for program in baseline["programs"]:
             # baseline[programs][program] = total budgetary impact of program
-            result[program] = dict(
-                baseline=baseline["programs"][program],
-                reform=reform["programs"][program],
-                difference=reform["programs"][program] - baseline["programs"][program],
-            )
+            result[program] = {
+                "baseline": baseline["programs"][program],
+                "reform": reform["programs"][program],
+                "difference": reform["programs"][program]
+                - baseline["programs"][program],
+            }
     return result
 
 
@@ -164,10 +167,10 @@ def decile_impact(baseline: dict, reform: dict) -> dict:
     )
     rel_decile_dict = rel_income_change_by_decile.to_dict()
     avg_decile_dict = avg_income_change_by_decile.to_dict()
-    return dict(
-        relative={int(k): v for k, v in rel_decile_dict.items()},
-        average={int(k): v for k, v in avg_decile_dict.items()},
-    )
+    return {
+        "relative": {int(k): v for k, v in rel_decile_dict.items()},
+        "average": {int(k): v for k, v in avg_decile_dict.items()},
+    }
 
 
 def wealth_decile_impact(baseline: dict, reform: dict) -> dict:
@@ -204,10 +207,10 @@ def wealth_decile_impact(baseline: dict, reform: dict) -> dict:
     )
     rel_decile_dict = rel_income_change_by_decile.to_dict()
     avg_decile_dict = avg_income_change_by_decile.to_dict()
-    return dict(
-        relative={int(k): v for k, v in rel_decile_dict.items()},
-        average={int(k): v for k, v in avg_decile_dict.items()},
-    )
+    return {
+        "relative": {int(k): v for k, v in rel_decile_dict.items()},
+        "average": {int(k): v for k, v in avg_decile_dict.items()},
+    }
 
 
 def inequality_impact(baseline: dict, reform: dict) -> dict:
@@ -221,20 +224,20 @@ def inequality_impact(baseline: dict, reform: dict) -> dict:
         dict: The impact of the reform on inequality.
 
     """
-    return dict(
-        gini=dict(
-            baseline=baseline["gini"],
-            reform=reform["gini"],
-        ),
-        top_10_pct_share=dict(
-            baseline=baseline["top_10_percent_share"],
-            reform=reform["top_10_percent_share"],
-        ),
-        top_1_pct_share=dict(
-            baseline=baseline["top_1_percent_share"],
-            reform=reform["top_1_percent_share"],
-        ),
-    )
+    return {
+        "gini": {
+            "baseline": baseline["gini"],
+            "reform": reform["gini"],
+        },
+        "top_10_pct_share": {
+            "baseline": baseline["top_10_percent_share"],
+            "reform": reform["top_10_percent_share"],
+        },
+        "top_1_pct_share": {
+            "baseline": baseline["top_1_percent_share"],
+            "reform": reform["top_1_percent_share"],
+        },
+    }
 
 
 def poverty_impact(baseline: dict, reform: dict) -> dict:
@@ -262,48 +265,48 @@ def poverty_impact(baseline: dict, reform: dict) -> dict:
     )
     age = MicroSeries(baseline["age"])
 
-    poverty = dict(
-        child=dict(
-            baseline=float(baseline_poverty[age < 18].mean()),
-            reform=float(reform_poverty[age < 18].mean()),
-        ),
-        adult=dict(
-            baseline=float(baseline_poverty[(age >= 18) & (age < 65)].mean()),
-            reform=float(reform_poverty[(age >= 18) & (age < 65)].mean()),
-        ),
-        senior=dict(
-            baseline=float(baseline_poverty[age >= 65].mean()),
-            reform=float(reform_poverty[age >= 65].mean()),
-        ),
-        all=dict(
-            baseline=float(baseline_poverty.mean()),
-            reform=float(reform_poverty.mean()),
-        ),
-    )
+    poverty = {
+        "child": {
+            "baseline": float(baseline_poverty[age < 18].mean()),
+            "reform": float(reform_poverty[age < 18].mean()),
+        },
+        "adult": {
+            "baseline": float(baseline_poverty[(age >= 18) & (age < 65)].mean()),
+            "reform": float(reform_poverty[(age >= 18) & (age < 65)].mean()),
+        },
+        "senior": {
+            "baseline": float(baseline_poverty[age >= 65].mean()),
+            "reform": float(reform_poverty[age >= 65].mean()),
+        },
+        "all": {
+            "baseline": float(baseline_poverty.mean()),
+            "reform": float(reform_poverty.mean()),
+        },
+    }
 
-    deep_poverty = dict(
-        child=dict(
-            baseline=float(baseline_deep_poverty[age < 18].mean()),
-            reform=float(reform_deep_poverty[age < 18].mean()),
-        ),
-        adult=dict(
-            baseline=float(baseline_deep_poverty[(age >= 18) & (age < 65)].mean()),
-            reform=float(reform_deep_poverty[(age >= 18) & (age < 65)].mean()),
-        ),
-        senior=dict(
-            baseline=float(baseline_deep_poverty[age >= 65].mean()),
-            reform=float(reform_deep_poverty[age >= 65].mean()),
-        ),
-        all=dict(
-            baseline=float(baseline_deep_poverty.mean()),
-            reform=float(reform_deep_poverty.mean()),
-        ),
-    )
+    deep_poverty = {
+        "child": {
+            "baseline": float(baseline_deep_poverty[age < 18].mean()),
+            "reform": float(reform_deep_poverty[age < 18].mean()),
+        },
+        "adult": {
+            "baseline": float(baseline_deep_poverty[(age >= 18) & (age < 65)].mean()),
+            "reform": float(reform_deep_poverty[(age >= 18) & (age < 65)].mean()),
+        },
+        "senior": {
+            "baseline": float(baseline_deep_poverty[age >= 65].mean()),
+            "reform": float(reform_deep_poverty[age >= 65].mean()),
+        },
+        "all": {
+            "baseline": float(baseline_deep_poverty.mean()),
+            "reform": float(reform_deep_poverty.mean()),
+        },
+    }
 
-    return dict(
-        poverty=poverty,
-        deep_poverty=deep_poverty,
-    )
+    return {
+        "poverty": poverty,
+        "deep_poverty": deep_poverty,
+    }
 
 
 def compute_income_change(
@@ -333,7 +336,7 @@ def intra_decile_impact(baseline: dict, reform: dict) -> dict:
     people = MicroSeries(
         baseline["household_count_people"], weights=baseline_income.weights
     )
-    decile = MicroSeries(baseline["household_income_decile"]).values
+    decile = MicroSeries(baseline["household_income_decile"]).values  # noqa: PD011  # MicroSeries overrides .values, and .to_numpy() emits a different warning
     income_change = compute_income_change(baseline_income.values, reform_income.values)
 
     # Within each decile, calculate the percentage of people who:
@@ -354,7 +357,7 @@ def intra_decile_impact(baseline: dict, reform: dict) -> dict:
         "Gain more than 5%",
     ]
     for lower, upper, label in zip(
-        income_change_bounds[:-1], income_change_bounds[1:], outcome_labels
+        income_change_bounds[:-1], income_change_bounds[1:], outcome_labels, strict=True
     ):
         outcome_groups[label] = []
         for i in range(1, 11):
@@ -374,7 +377,7 @@ def intra_decile_impact(baseline: dict, reform: dict) -> dict:
             outcome_groups[label].append(people_in_proportion)
 
         all_outcomes[label] = sum(outcome_groups[label]) / 10
-    return dict(deciles=outcome_groups, all=all_outcomes)
+    return {"deciles": outcome_groups, "all": all_outcomes}
 
 
 def intra_wealth_decile_impact(baseline: dict, reform: dict) -> dict:
@@ -392,7 +395,7 @@ def intra_wealth_decile_impact(baseline: dict, reform: dict) -> dict:
     people = MicroSeries(
         baseline["household_count_people"], weights=baseline_income.weights
     )
-    decile = MicroSeries(baseline["household_wealth_decile"]).values
+    decile = MicroSeries(baseline["household_wealth_decile"]).values  # noqa: PD011  # MicroSeries overrides .values, and .to_numpy() emits a different warning
     income_change = compute_income_change(baseline_income.values, reform_income.values)
 
     # Within each decile, calculate the percentage of people who:
@@ -413,7 +416,7 @@ def intra_wealth_decile_impact(baseline: dict, reform: dict) -> dict:
         "Gain more than 5%",
     ]
     for lower, upper, label in zip(
-        income_change_bounds[:-1], income_change_bounds[1:], outcome_labels
+        income_change_bounds[:-1], income_change_bounds[1:], outcome_labels, strict=True
     ):
         outcome_groups[label] = []
         for i in range(1, 11):
@@ -433,7 +436,7 @@ def intra_wealth_decile_impact(baseline: dict, reform: dict) -> dict:
             outcome_groups[label].append(people_in_proportion)
 
         all_outcomes[label] = sum(outcome_groups[label]) / 10
-    return dict(deciles=outcome_groups, all=all_outcomes)
+    return {"deciles": outcome_groups, "all": all_outcomes}
 
 
 def poverty_gender_breakdown(baseline: dict, reform: dict) -> dict:
@@ -463,32 +466,32 @@ def poverty_gender_breakdown(baseline: dict, reform: dict) -> dict:
     )
     is_male = MicroSeries(baseline["is_male"])
 
-    poverty = dict(
-        male=dict(
-            baseline=float(baseline_poverty[is_male].mean()),
-            reform=float(reform_poverty[is_male].mean()),
-        ),
-        female=dict(
-            baseline=float(baseline_poverty[~is_male].mean()),
-            reform=float(reform_poverty[~is_male].mean()),
-        ),
-    )
+    poverty = {
+        "male": {
+            "baseline": float(baseline_poverty[is_male].mean()),
+            "reform": float(reform_poverty[is_male].mean()),
+        },
+        "female": {
+            "baseline": float(baseline_poverty[~is_male].mean()),
+            "reform": float(reform_poverty[~is_male].mean()),
+        },
+    }
 
-    deep_poverty = dict(
-        male=dict(
-            baseline=float(baseline_deep_poverty[is_male].mean()),
-            reform=float(reform_deep_poverty[is_male].mean()),
-        ),
-        female=dict(
-            baseline=float(baseline_deep_poverty[~is_male].mean()),
-            reform=float(reform_deep_poverty[~is_male].mean()),
-        ),
-    )
+    deep_poverty = {
+        "male": {
+            "baseline": float(baseline_deep_poverty[is_male].mean()),
+            "reform": float(reform_deep_poverty[is_male].mean()),
+        },
+        "female": {
+            "baseline": float(baseline_deep_poverty[~is_male].mean()),
+            "reform": float(reform_deep_poverty[~is_male].mean()),
+        },
+    }
 
-    return dict(
-        poverty=poverty,
-        deep_poverty=deep_poverty,
-    )
+    return {
+        "poverty": poverty,
+        "deep_poverty": deep_poverty,
+    }
 
 
 def poverty_racial_breakdown(baseline: dict, reform: dict) -> dict:
@@ -512,28 +515,28 @@ def poverty_racial_breakdown(baseline: dict, reform: dict) -> dict:
     )
     race = MicroSeries(baseline["race"])  # Can be WHITE, BLACK, HISPANIC, or OTHER.
 
-    poverty = dict(
-        white=dict(
-            baseline=float(baseline_poverty[race == "WHITE"].mean()),
-            reform=float(reform_poverty[race == "WHITE"].mean()),
-        ),
-        black=dict(
-            baseline=float(baseline_poverty[race == "BLACK"].mean()),
-            reform=float(reform_poverty[race == "BLACK"].mean()),
-        ),
-        hispanic=dict(
-            baseline=float(baseline_poverty[race == "HISPANIC"].mean()),
-            reform=float(reform_poverty[race == "HISPANIC"].mean()),
-        ),
-        other=dict(
-            baseline=float(baseline_poverty[race == "OTHER"].mean()),
-            reform=float(reform_poverty[race == "OTHER"].mean()),
-        ),
-    )
+    poverty = {
+        "white": {
+            "baseline": float(baseline_poverty[race == "WHITE"].mean()),
+            "reform": float(reform_poverty[race == "WHITE"].mean()),
+        },
+        "black": {
+            "baseline": float(baseline_poverty[race == "BLACK"].mean()),
+            "reform": float(reform_poverty[race == "BLACK"].mean()),
+        },
+        "hispanic": {
+            "baseline": float(baseline_poverty[race == "HISPANIC"].mean()),
+            "reform": float(reform_poverty[race == "HISPANIC"].mean()),
+        },
+        "other": {
+            "baseline": float(baseline_poverty[race == "OTHER"].mean()),
+            "reform": float(reform_poverty[race == "OTHER"].mean()),
+        },
+    }
 
-    return dict(
-        poverty=poverty,
-    )
+    return {
+        "poverty": poverty,
+    }
 
 
 class UKConstituencyBreakdownByConstituency(BaseModel):
@@ -577,7 +580,7 @@ class UKLocalAuthorityBreakdown(BaseModel):
 
 
 def uk_constituency_breakdown(
-    baseline: dict, reform: dict, country_id: str, region: str | None = None
+    baseline: dict, reform: dict, country_id: str | None, region: str | None = None
 ) -> UKConstituencyBreakdown | None:
     """Return each UK constituency's average and relative household income change.
 
@@ -647,9 +650,12 @@ def uk_constituency_breakdown(
         code: str = constituency_names.iloc[i]["code"]
 
         # Filter to specific constituency if requested
-        if selected_constituency is not None:
-            if name != selected_constituency and code != selected_constituency:
-                continue
+        if (
+            selected_constituency is not None
+            and name != selected_constituency
+            and code != selected_constituency
+        ):
+            continue
 
         # Filter to specific country if requested. Constituency codes
         # are prefixed with a single letter that identifies the
@@ -710,7 +716,7 @@ def uk_constituency_breakdown(
 
 
 def uk_local_authority_breakdown(
-    baseline: dict, reform: dict, country_id: str, region: str | None = None
+    baseline: dict, reform: dict, country_id: str | None, region: str | None = None
 ) -> UKLocalAuthorityBreakdown | None:
     """Return each UK local authority's average and relative household income change.
 
@@ -776,9 +782,8 @@ def uk_local_authority_breakdown(
         code: str = local_authority_names.iloc[i]["code"]
 
         # Filter to specific local authority if requested
-        if selected_la is not None:
-            if name != selected_la and code != selected_la:
-                continue
+        if selected_la is not None and name != selected_la and code != selected_la:
+            continue
 
         # Filter to specific country if requested
         if selected_country is not None:
@@ -837,7 +842,7 @@ def uk_local_authority_breakdown(
 def compare_economic_outputs(
     baseline: dict,
     reform: dict,
-    country_id: str = None,
+    country_id: str | None = None,
     region: str | None = None,
 ) -> dict:
     """Compare the economic outputs of two economies.
@@ -888,30 +893,30 @@ def compare_economic_outputs(
             wealth_decile_impact_data = {}
             intra_wealth_decile_impact_data = {}
 
-        return dict(
-            budget=budgetary_impact_data,
-            detailed_budget=detailed_budgetary_impact_data,
-            decile=decile_impact_data,
-            inequality=inequality_impact_data,
-            poverty=poverty_impact_data,
-            poverty_by_gender=poverty_by_gender_data,
-            poverty_by_race=poverty_by_race_data,
-            intra_decile=intra_decile_impact_data,
-            wealth_decile=wealth_decile_impact_data,
-            intra_wealth_decile=intra_wealth_decile_impact_data,
-            labor_supply_response=labor_supply_response_data,
-            constituency_impact=constituency_impact_data,
-            local_authority_impact=local_authority_impact_data,
-        )
+        return {
+            "budget": budgetary_impact_data,
+            "detailed_budget": detailed_budgetary_impact_data,
+            "decile": decile_impact_data,
+            "inequality": inequality_impact_data,
+            "poverty": poverty_impact_data,
+            "poverty_by_gender": poverty_by_gender_data,
+            "poverty_by_race": poverty_by_race_data,
+            "intra_decile": intra_decile_impact_data,
+            "wealth_decile": wealth_decile_impact_data,
+            "intra_wealth_decile": intra_wealth_decile_impact_data,
+            "labor_supply_response": labor_supply_response_data,
+            "constituency_impact": constituency_impact_data,
+            "local_authority_impact": local_authority_impact_data,
+        }
     if baseline.get("type") == "cliff":
-        return dict(
-            baseline=dict(
-                cliff_gap=baseline["cliff_gap"],
-                cliff_share=baseline["cliff_share"],
-            ),
-            reform=dict(
-                cliff_gap=reform["cliff_gap"],
-                cliff_share=reform["cliff_share"],
-            ),
-        )
+        return {
+            "baseline": {
+                "cliff_gap": baseline["cliff_gap"],
+                "cliff_share": baseline["cliff_share"],
+            },
+            "reform": {
+                "cliff_gap": reform["cliff_gap"],
+                "cliff_share": reform["cliff_share"],
+            },
+        }
     return None
diff --git a/policyengine_api/services/economy_service.py b/policyengine_api/services/economy_service.py
index d14b0a263..3894262d4 100644
--- a/policyengine_api/services/economy_service.py
+++ b/policyengine_api/services/economy_service.py
@@ -1,5 +1,6 @@
 """Economic impact service backed by cached reform impacts and simulation jobs."""
 
+import contextlib
 import datetime
 import hashlib
 import json
@@ -1402,15 +1403,15 @@ def _record_uncertifiable_stored_impact(
             return
         if most_recent_impact.options_hash != setup_options.options_hash:
             return
-        try:
+        # Best effort: the typed SPM error is the answer, and the failure is
+        # already logged.
+        with contextlib.suppress(Exception):
             self._set_reform_impact_error(
                 setup_options=setup_options,
                 message=error.message,
                 error_code=error.code,
                 execution_id=most_recent_impact.execution_id,
             )
-        except Exception:  # noqa: BLE001, S110  # best effort: the typed SPM error is the answer, and the failure is already logged
-            pass
 
     @observability_runtime.span(ECONOMY_ANNUAL_STAGES.name(Stage.ECONOMY_READ_FAILED))
     def _handle_failed_impact(
@@ -1556,6 +1557,7 @@ def _setup_sim_options(
         region: str,
         time_period: str,
         scope: Literal["macro", "household"] = "macro",
+        *,
         include_cliffs: bool = False,
         model_version: str | None = None,
         policyengine_version: str | None = None,
@@ -1676,18 +1678,26 @@ def _with_policyengine_bundle(
             "dataset": setup_options.dataset,
         }
         if isinstance(result.get("policyengine_bundle"), dict):
-            for key, value in result["policyengine_bundle"].items():
-                if value is not None:
-                    bundle[key] = value
+            bundle.update(
+                {
+                    key: value
+                    for key, value in result["policyengine_bundle"].items()
+                    if value is not None
+                }
+            )
         execution_bundle = (
             getattr(execution, "policyengine_bundle", None)
             if execution is not None
             else None
         )
         if isinstance(execution_bundle, dict):
-            for key, value in execution_bundle.items():
-                if value is not None:
-                    bundle[key] = value
+            bundle.update(
+                {
+                    key: value
+                    for key, value in execution_bundle.items()
+                    if value is not None
+                }
+            )
         response = {
             **result,
             "policyengine_bundle": bundle,
@@ -1818,7 +1828,7 @@ def _set_reform_impact_computing(
         except Exception as e:
             logger.log_struct(
                 {
-                    "message": f"Error inserting computing record: {str(e)}",
+                    "message": f"Error inserting computing record: {e!s}",
                     **setup_options.model_dump(),
                 }
             )
@@ -1849,9 +1859,7 @@ def _set_reform_impact_complete(
         except Exception as e:
             logger.log_struct(
                 {
-                    "message": (
-                        f"Error setting completed reform impact record: {str(e)}"
-                    ),
+                    "message": (f"Error setting completed reform impact record: {e!s}"),
                     **setup_options.model_dump(),
                 }
             )
@@ -1884,7 +1892,7 @@ def _set_reform_impact_error(
         except Exception as e:
             logger.log_struct(
                 {
-                    "message": f"Error setting error reform impact record: {str(e)}",
+                    "message": f"Error setting error reform impact record: {e!s}",
                     **setup_options.model_dump(),
                 }
             )
diff --git a/policyengine_api/services/household_mirroring.py b/policyengine_api/services/household_mirroring.py
index 189401cb5..d2df711c3 100644
--- a/policyengine_api/services/household_mirroring.py
+++ b/policyengine_api/services/household_mirroring.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from typing import TYPE_CHECKING, Protocol
 
@@ -90,7 +91,8 @@ def _log_copy_operation(
     result: LegacyHouseholdPersistenceResult | None = None,
     failure_category: str | None = None,
 ) -> None:
-    try:
+    # Metric logging must not change the mirror outcome.
+    with contextlib.suppress(Exception):
         logger.log_struct(
             {
                 "message": "V1 household immediate copy completed",
@@ -117,8 +119,6 @@ def _log_copy_operation(
             },
             severity="INFO" if outcome == "ok" else "ERROR",
         )
-    except Exception:  # noqa: BLE001, S110  # metric logging must not change the mirror outcome
-        pass
 
 
 def process_household_event_after_commit(
diff --git a/policyengine_api/services/policy_mirroring.py b/policyengine_api/services/policy_mirroring.py
index 674d9c75b..ee067ce88 100644
--- a/policyengine_api/services/policy_mirroring.py
+++ b/policyengine_api/services/policy_mirroring.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from typing import TYPE_CHECKING, Protocol
 
@@ -97,7 +98,8 @@ def _log_mirror_event(
     policy_created: bool | None = None,
     mapping_created: bool | None = None,
 ) -> None:
-    try:
+    # Metric logging must not change the mirror outcome.
+    with contextlib.suppress(Exception):
         logger.log_struct(
             {
                 "message": "V1 policy immediate mirror completed",
@@ -121,8 +123,6 @@ def _log_mirror_event(
             },
             severity="INFO" if outcome == "ok" else "ERROR",
         )
-    except Exception:  # noqa: BLE001, S110  # metric logging must not change the mirror outcome
-        pass
 
 
 def mirror_policy_after_commit(
diff --git a/policyengine_api/services/reform_impacts_service.py b/policyengine_api/services/reform_impacts_service.py
index 5ac0ba95c..813f2a8d9 100644
--- a/policyengine_api/services/reform_impacts_service.py
+++ b/policyengine_api/services/reform_impacts_service.py
@@ -1,5 +1,6 @@
 """Recoverable reform-impact cache service backed by shared Redis."""
 
+import contextlib
 import datetime
 from typing import Any
 
@@ -158,7 +159,7 @@ def release_reform_impact_start(
         observability_id: str,
     ) -> None:
         """Best-effort release; an unavailable cache safely falls back to expiry."""
-        try:
+        with contextlib.suppress(CacheCoordinationError):
             self._cache.release_start(
                 country_id=country_id,
                 reform_policy_id=policy_id,
@@ -172,8 +173,6 @@ def release_reform_impact_start(
                 claim_token=claim_token,
                 observability_id=observability_id,
             )
-        except CacheCoordinationError:
-            pass
 
     def set_reform_impact(
         self,
diff --git a/policyengine_api/services/user_policy_mirroring.py b/policyengine_api/services/user_policy_mirroring.py
index 08f7a7c62..20bd71ff7 100644
--- a/policyengine_api/services/user_policy_mirroring.py
+++ b/policyengine_api/services/user_policy_mirroring.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from typing import TYPE_CHECKING, Protocol
 
@@ -112,7 +113,8 @@ def _log_mirror_operation(
     result: LegacyUserPolicyPersistenceResult | None = None,
     failure_category: str | None = None,
 ) -> None:
-    try:
+    # Metric logging must not change the mirror outcome.
+    with contextlib.suppress(Exception):
         logger.log_struct(
             {
                 "message": "V1 saved-policy immediate mirror completed",
@@ -146,8 +148,6 @@ def _log_mirror_operation(
             },
             severity="INFO" if outcome == "ok" else "ERROR",
         )
-    except Exception:  # noqa: BLE001, S110  # metric logging must not change the mirror outcome
-        pass
 
 
 def _run_user_policy_mirror(
diff --git a/policyengine_api/services/v2/associations/validators.py b/policyengine_api/services/v2/associations/validators.py
index 4d9075eb9..a5cff660e 100644
--- a/policyengine_api/services/v2/associations/validators.py
+++ b/policyengine_api/services/v2/associations/validators.py
@@ -44,7 +44,7 @@ def require_legacy_reference_checker(
     return legacy_references
 
 
-def require_not_mirror_owned(mirror_owned: bool, *, association_id: UUID) -> None:
+def require_not_mirror_owned(*, mirror_owned: bool, association_id: UUID) -> None:
     """Raise MirrorOwnedAssociationError if the v1 saved-policy mirror owns the row."""
     if mirror_owned:
         msg = (
diff --git a/policyengine_api/services/v2/comparison_runs/__init__.py b/policyengine_api/services/v2/comparison_runs/__init__.py
index a0e8f6084..52d7ddf5b 100644
--- a/policyengine_api/services/v2/comparison_runs/__init__.py
+++ b/policyengine_api/services/v2/comparison_runs/__init__.py
@@ -11,10 +11,10 @@
 )
 
 __all__ = [
-    "ComparisonRunAggregationStatus",
-    "ComparisonRunLifecycleStatus",
     "ComparisonReportPersistenceResult",
     "ComparisonReportRecord",
+    "ComparisonRunAggregationStatus",
+    "ComparisonRunLifecycleStatus",
     "ComparisonSimulationPersistenceResult",
     "ComparisonSimulationRecord",
     "ResultComparisonStatus",
diff --git a/policyengine_api/services/v2/user_policies/services.py b/policyengine_api/services/v2/user_policies/services.py
index 508819a83..24bfaa795 100644
--- a/policyengine_api/services/v2/user_policies/services.py
+++ b/policyengine_api/services/v2/user_policies/services.py
@@ -557,7 +557,9 @@ def patch_user_policy(
                 association_id=association_id,
             )
             require_not_mirror_owned(
-                read_user_policy_mirror_exists(session, association_id=association.id),
+                mirror_owned=read_user_policy_mirror_exists(
+                    session, association_id=association.id
+                ),
                 association_id=association.id,
             )
             repointed_policy_id = (
@@ -602,7 +604,9 @@ def delete_user_policy(
                 association_id=association_id,
             )
             require_not_mirror_owned(
-                read_user_policy_mirror_exists(session, association_id=association.id),
+                mirror_owned=read_user_policy_mirror_exists(
+                    session, association_id=association.id
+                ),
                 association_id=association.id,
             )
             delete_user_policy(session, association)
diff --git a/policyengine_api/services/v2/user_reports/services.py b/policyengine_api/services/v2/user_reports/services.py
index f3e218bb8..0fae168de 100644
--- a/policyengine_api/services/v2/user_reports/services.py
+++ b/policyengine_api/services/v2/user_reports/services.py
@@ -109,7 +109,7 @@ def validate_linked_user_policy(
     if user_policy_id is None:
         return
     require_owned_user_policy(
-        read_owned_user_policy_exists(
+        owned=read_owned_user_policy_exists(
             session,
             user_id=user_id,
             country_id=country_id,
diff --git a/policyengine_api/services/v2/user_reports/validators.py b/policyengine_api/services/v2/user_reports/validators.py
index bea15ad78..7d670ed35 100644
--- a/policyengine_api/services/v2/user_reports/validators.py
+++ b/policyengine_api/services/v2/user_reports/validators.py
@@ -31,7 +31,7 @@ def require_user_report(
     return association
 
 
-def require_owned_user_policy(owned: bool, *, user_policy_id: UUID) -> None:
+def require_owned_user_policy(*, owned: bool, user_policy_id: UUID) -> None:
     """Raise AssociationLinkNotFoundError unless a linked saved policy is ``owned``.
 
     ``owned`` says whether the report's owner has that saved policy in the
diff --git a/policyengine_api/spm.py b/policyengine_api/spm.py
index 932149b93..2f87ba09c 100644
--- a/policyengine_api/spm.py
+++ b/policyengine_api/spm.py
@@ -444,7 +444,7 @@ def resolved_spm_settings(settings: object) -> dict | None:
         config = SPMSelection.model_validate(settings)
     except ValidationError:
         return None
-    if not REQUIRED_RESOLVED_SPM_FIELDS <= config.model_fields_set:
+    if not config.model_fields_set >= REQUIRED_RESOLVED_SPM_FIELDS:
         return None
     return {name: getattr(config, name) for name in SPMSelection.model_fields}
 
@@ -479,7 +479,9 @@ def _installed_country_implements_spm(country_id: str) -> bool:
         COUNTRY_PACKAGE_NAMES,
     )
 
-    package_name = dict(zip(COUNTRIES, COUNTRY_PACKAGE_NAMES)).get(country_id)
+    package_name = dict(zip(COUNTRIES, COUNTRY_PACKAGE_NAMES, strict=True)).get(
+        country_id
+    )
     if package_name is None:
         return False
     try:
diff --git a/policyengine_api/utils/cache_utils.py b/policyengine_api/utils/cache_utils.py
index c5f8bf516..927f0d93b 100644
--- a/policyengine_api/utils/cache_utils.py
+++ b/policyengine_api/utils/cache_utils.py
@@ -8,8 +8,7 @@
 import flask
 
 
-def make_cache_key(*args: object, **kwargs: object) -> str:
-    # pylint: disable=unused-argument
+def make_cache_key(*_args: object, **_kwargs: object) -> str:
     """Hash the current request's full path and JSON or form body into a cache key.
 
     The arguments are ignored. Keep it fast: adding overhead for a minor extra
diff --git a/policyengine_api/utils/payload_validators/validate_household_payload.py b/policyengine_api/utils/payload_validators/validate_household_payload.py
index 5eb1cbca9..f7c495e6d 100644
--- a/policyengine_api/utils/payload_validators/validate_household_payload.py
+++ b/policyengine_api/utils/payload_validators/validate_household_payload.py
@@ -28,9 +28,12 @@ def validate_household_payload(
         return False, f"Missing required keys: {missing_keys}"
 
     # Check that label is either string or None, if present
-    if "label" in payload:
-        if payload["label"] is not None and not isinstance(payload["label"], str):
-            return False, "Label must be a string or None"
+    if (
+        "label" in payload
+        and payload["label"] is not None
+        and not isinstance(payload["label"], str)
+    ):
+        return False, "Label must be a string or None"
 
     # Check that data is a dictionary
     if not isinstance(payload["data"], dict):
diff --git a/policyengine_api/utils/payload_validators/validate_set_policy_payload.py b/policyengine_api/utils/payload_validators/validate_set_policy_payload.py
index 9c9d2f098..5e3bef36d 100644
--- a/policyengine_api/utils/payload_validators/validate_set_policy_payload.py
+++ b/policyengine_api/utils/payload_validators/validate_set_policy_payload.py
@@ -13,9 +13,12 @@ def validate_set_policy_payload(payload: dict) -> tuple[bool, str | None]:
         return False, f"Missing required keys: {missing_keys}"
 
     # Check that label is either string or None
-    if "label" in payload:
-        if payload["label"] is not None and not isinstance(payload["label"], str):
-            return False, "Label must be a string or None"
+    if (
+        "label" in payload
+        and payload["label"] is not None
+        and not isinstance(payload["label"], str)
+    ):
+        return False, "Label must be a string or None"
 
     # Check that data is a dictionary
     if not isinstance(payload["data"], dict):
diff --git a/policyengine_api/utils/singleton.py b/policyengine_api/utils/singleton.py
index bc801566f..47217101a 100644
--- a/policyengine_api/utils/singleton.py
+++ b/policyengine_api/utils/singleton.py
@@ -1,10 +1,12 @@
 """Metaclass for classes that have a single shared instance per process."""
 
+from typing import ClassVar
+
 
 class Singleton(type):
     """Metaclass whose classes build one instance and return it on every later call."""
 
-    _instances = {}
+    _instances: ClassVar[dict[type, object]] = {}
 
     def __call__(cls, *args: object, **kwargs: object) -> object:
         """Return the shared instance, creating it on the first call.
diff --git a/policyengine_api/worker_spm_release.py b/policyengine_api/worker_spm_release.py
index 2efe488f9..bd1f5528c 100644
--- a/policyengine_api/worker_spm_release.py
+++ b/policyengine_api/worker_spm_release.py
@@ -27,8 +27,8 @@ def __init__(self, registry: dict) -> None:
 
     def get_spm_capability(
         self,
-        country: str,
-        model_version: str | None,
+        country: str,  # noqa: ARG002  # implements SPMCapabilitySource.get_spm_capability
+        model_version: str | None,  # noqa: ARG002  # implements SPMCapabilitySource.get_spm_capability
         *,
         policyengine_version: str | None,
     ) -> object:
@@ -80,7 +80,7 @@ def validate_installed_worker(registry: dict, expected_bundle: str) -> dict | No
     if versions["policyengine"] != expected_bundle:
         msg = "The bundle manifest differs from the release requirement"
         raise ValueError(msg)
-    if constants.POLICYENGINE_VERSION != expected_bundle:
+    if expected_bundle != constants.POLICYENGINE_VERSION:
         msg = "The API runtime differs from the release requirement"
         raise ValueError(msg)
 
diff --git a/pyproject.toml b/pyproject.toml
index 7e014260b..39d4cd065 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -118,6 +118,8 @@ select = [
     "DTZ", "ERA", "EXE", "FIX", "G", "LOG", "S", "T20", "TD",
     # Group 7: structure and imports.
     "A", "E", "FAST", "INP", "N", "PLC", "SLF", "TID253",
+    # Group 8a: arguments, idioms and pytest style.
+    "ARG", "ASYNC", "B", "C4", "FBT", "PD", "PERF", "PGH", "PLW", "PT", "PTH", "RUF", "SIM",
 ]
 # Mutually exclusive pydocstyle pairs: keep D211 (no blank line before a class
 # docstring) and D212 (summary on the first line).
@@ -137,12 +139,16 @@ exclude = ["migrations/*/versions/*.py"]
 # live in directories that aren't packages, import inside a test (often after
 # patching the environment), and use fake credentials, naive datetimes,
 # subprocess calls to repository scripts, SQL built from strings and prints,
-# and may import the lazily loaded packages at module level. Every other rule
-# applies to tests.
+# may import the lazily loaded packages at module level, and may leave a
+# stand-in's arguments unused. Every other rule applies to tests.
 "**/tests/**" = [
-    "ANN", "D1", "DTZ001", "DTZ011", "INP001", "PLC0415", "PLR2004", "S101",
-    "S105", "S106", "S603", "S607", "S608", "SLF001", "T201", "TID253",
+    "ANN", "ARG001", "ARG002", "ARG005", "D1", "DTZ001", "DTZ011", "INP001",
+    "PLC0415", "PLR2004", "S101", "S105", "S106", "S603", "S607", "S608",
+    "SLF001", "T201", "TID253",
 ]
+# The shared rules tool needs only the standard library, so its tests use
+# unittest on purpose; pytest-style rules don't apply to them.
+"scripts/rules/tests/**" = ["PT"]
 # CI/CD scripts print their results, fetch fixed URLs and may import the
 # lazily loaded packages at module level.
 ".github/**" = ["S310", "T201", "TID253"]
diff --git a/rules/registry.toml b/rules/registry.toml
index 33bf32d48..550c62a24 100644
--- a/rules/registry.toml
+++ b/rules/registry.toml
@@ -700,7 +700,7 @@ autofix = true
 [rule.enforcer]
 kind = "ruff"
 mode = "lint"
-codes = ["A", "ANN", "BLE", "D", "DTZ", "E", "E4", "E7", "E9", "EM", "ERA", "EXE", "F", "FAST", "FIX", "FLY", "FURB", "G", "I", "INP", "LOG", "N", "PIE", "PLC", "PYI", "RET", "RSE", "S", "SLF", "T20", "TC", "TD", "TID253", "TRY", "UP", "W"]
+codes = ["A", "ANN", "ARG", "ASYNC", "B", "BLE", "C4", "D", "DTZ", "E", "E4", "E7", "E9", "EM", "ERA", "EXE", "F", "FAST", "FBT", "FIX", "FLY", "FURB", "G", "I", "INP", "LOG", "N", "PD", "PERF", "PGH", "PIE", "PLC", "PLW", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "S", "SIM", "SLF", "T20", "TC", "TD", "TID253", "TRY", "UP", "W"]
 [[rule.ci]]
 workflow = ".github/workflows/pr.yml"
 job = "lint"
@@ -744,7 +744,7 @@ kind = "none"
 [[rule]]
 id = "api.quality.tests-ruff-exemptions"
 category = "quality"
-statement = "Test files may use pytest's bare assert, need no docstrings, annotations or named constants for magic numbers, and may reach into private members, live outside packages and import inside a test (S101, D1, ANN, PLR2004, SLF001, INP001, PLC0415). They may also use fake credentials, naive datetimes, subprocess calls to repository scripts, SQL built from strings and prints (S105, S106, DTZ001, DTZ011, S603, S607, S608, T201), and may import the lazily loaded packages at module level (TID253). Every other ruff rule applies to tests."
+statement = "Test files may use pytest's bare assert, need no docstrings, annotations or named constants for magic numbers, and may reach into private members, live outside packages and import inside a test (S101, D1, ANN, PLR2004, SLF001, INP001, PLC0415). They may also use fake credentials, naive datetimes, subprocess calls to repository scripts, SQL built from strings and prints (S105, S106, DTZ001, DTZ011, S603, S607, S608, T201), may import the lazily loaded packages at module level (TID253), and may leave a stand-in's arguments unused (ARG001, ARG002, ARG005). Every other ruff rule applies to tests."
 rationale = "docs/engineering/skills/rules-registry.md#file-level-exceptions"
 scope = ["tests/**/*.py", "scripts/rules/tests/**/*.py"]
 tier = "mechanical"
@@ -754,7 +754,7 @@ autofix = false
 kind = "ruff"
 mode = "per-file-ignore"
 pattern = "**/tests/**"
-codes = ["ANN", "D1", "DTZ001", "DTZ011", "INP001", "PLC0415", "PLR2004", "S101", "S105", "S106", "S603", "S607", "S608", "SLF001", "T201", "TID253"]
+codes = ["ANN", "ARG001", "ARG002", "ARG005", "D1", "DTZ001", "DTZ011", "INP001", "PLC0415", "PLR2004", "S101", "S105", "S106", "S603", "S607", "S608", "SLF001", "T201", "TID253"]
 [[rule.ci]]
 workflow = ".github/workflows/pr.yml"
 job = "lint"
@@ -823,6 +823,25 @@ workflow = ".github/workflows/pr.yml"
 job = "lint"
 invocation = "ruff check ."
 
+
+[[rule]]
+id = "api.quality.unittest-ruff-exemptions"
+category = "quality"
+statement = "The shared rules tool's tests use unittest, because the tool needs only the standard library, so ruff's pytest-style rules (PT) don't apply to them."
+rationale = "docs/engineering/skills/rules-registry.md#baselines"
+scope = ["scripts/rules/tests/**/*.py"]
+tier = "mechanical"
+status = "enforced"
+autofix = false
+[rule.enforcer]
+kind = "ruff"
+mode = "per-file-ignore"
+pattern = "scripts/rules/tests/**"
+codes = ["PT"]
+[[rule.ci]]
+workflow = ".github/workflows/pr.yml"
+job = "lint"
+invocation = "ruff check ."
 [[rule]]
 id = "api.quality.mypy-v2"
 category = "quality"
diff --git a/scripts/compare_migration_baseline.py b/scripts/compare_migration_baseline.py
index d3f320526..6451e95f9 100644
--- a/scripts/compare_migration_baseline.py
+++ b/scripts/compare_migration_baseline.py
@@ -136,8 +136,10 @@ def compare(
                 f"(≤ {p95_limit:.2f}ms)"
             )
 
-    for name in sorted(set(candidate_stats) - set(baseline_stats)):
-        lines.append(f"NOTE {name}: not in baseline; not gated")
+    lines.extend(
+        f"NOTE {name}: not in baseline; not gated"
+        for name in sorted(set(candidate_stats) - set(baseline_stats))
+    )
 
     return passed, lines
 
diff --git a/scripts/guards/migration_contracts.py b/scripts/guards/migration_contracts.py
index 3018357a5..95c65defa 100644
--- a/scripts/guards/migration_contracts.py
+++ b/scripts/guards/migration_contracts.py
@@ -23,16 +23,13 @@ def _check_unique_values(
     *,
     label: str,
 ) -> list[str]:
-    violations = []
     seen: set[str] = set()
     duplicates: set[str] = set()
     for value in values:
         if value in seen:
             duplicates.add(value)
         seen.add(value)
-    for value in sorted(duplicates):
-        violations.append(f"duplicate {label}: {value!r}")
-    return violations
+    return [f"duplicate {label}: {value!r}" for value in sorted(duplicates)]
 
 
 def _check_route_groups(payload: dict[str, Any]) -> list[str]:
diff --git a/scripts/measure_cloud_run_runtime.py b/scripts/measure_cloud_run_runtime.py
index 80c1eff61..212c52b46 100644
--- a/scripts/measure_cloud_run_runtime.py
+++ b/scripts/measure_cloud_run_runtime.py
@@ -152,7 +152,7 @@ def _summarize_endpoint(records: list[dict], duration_seconds: float) -> dict:
 
 
 async def _run(args: argparse.Namespace) -> dict:
-    base_payload = json.loads(Path(args.calculate_payload).read_text())
+    base_payload = json.loads(Path(args.calculate_payload).read_text())  # noqa: ASYNC240  # one small read before any request starts, with nothing else running yet
     base_payload["household"]["axes"][0][0]["count"] = args.axes_count
     cache_bust = args.cache_bust == "always"
     run_token = uuid.uuid4().hex[:8]
diff --git a/scripts/process_v1_household_mirror_event.py b/scripts/process_v1_household_mirror_event.py
index 7785598e5..a4bc184ad 100755
--- a/scripts/process_v1_household_mirror_event.py
+++ b/scripts/process_v1_household_mirror_event.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import argparse
+import contextlib
 import json
 import os
 import sys
@@ -217,7 +218,8 @@ def main(
                 require_pending=True,
             )
     except Exception as error:  # noqa: BLE001  # command emits a safe result
-        try:
+        # Outcome logging must not change the command result.
+        with contextlib.suppress(Exception):
             _record_command_outcome(
                 identity=identity,
                 country_id=args.country_id,
@@ -225,8 +227,6 @@ def main(
                 outcome="error",
                 error_type=type(error).__name__,
             )
-        except Exception:  # noqa: BLE001  # outcome logging must not change the command result
-            pass
         safe_types = (HouseholdEventCommandConfigurationError,)
         message = (
             str(error)
@@ -249,7 +249,8 @@ def main(
     finally:
         if v1_engine is not None:
             v1_engine.dispose()
-    try:
+    # Outcome logging must not change the command result.
+    with contextlib.suppress(Exception):
         _record_command_outcome(
             identity=identity,
             country_id=args.country_id,
@@ -257,8 +258,6 @@ def main(
             outcome="ok",
             destination_household_id=result.household_id,
         )
-    except Exception:  # noqa: BLE001  # outcome logging must not change the command result
-        pass
     print(
         json.dumps(
             {
diff --git a/scripts/rules/adapters.py b/scripts/rules/adapters.py
index a16c5b40c..81890218d 100644
--- a/scripts/rules/adapters.py
+++ b/scripts/rules/adapters.py
@@ -30,7 +30,7 @@ def check_adapters(agents: Agents, root: Path) -> list[Violation]:
             continue
         text = path.read_text()
 
-        def v(message: str, fix: str) -> None:
+        def v(message: str, fix: str, adapter: str = adapter) -> None:
             violations.append(Violation(None, "adapters", f"{adapter} {message}", fix))
 
         if instructions not in text:
diff --git a/scripts/rules/baseline.py b/scripts/rules/baseline.py
index 2af9b1ac5..62fa76c6f 100644
--- a/scripts/rules/baseline.py
+++ b/scripts/rules/baseline.py
@@ -33,6 +33,7 @@ def load_base_registry(root: Path, ref: str) -> Registry | None:
         cwd=root,
         capture_output=True,
         text=True,
+        check=False,
     )
     if verify.returncode != 0:
         raise BaseUnavailableError(ref)
@@ -41,6 +42,7 @@ def load_base_registry(root: Path, ref: str) -> Registry | None:
         cwd=root,
         capture_output=True,
         text=True,
+        check=False,
     )
     if shown.returncode != 0:
         return None
@@ -85,6 +87,8 @@ def check_baselines(
                         "explicit and reviewable",
                     )
                 )
-    for rule_id in sorted(current_ids - {rule.id for rule in base.rules}):
-        notes.append(f"rule {rule_id} is new")
+    notes.extend(
+        f"rule {rule_id} is new"
+        for rule_id in sorted(current_ids - {rule.id for rule in base.rules})
+    )
     return violations, notes
diff --git a/scripts/rules/ci_scripts.py b/scripts/rules/ci_scripts.py
index 77fe38324..077c0f84d 100644
--- a/scripts/rules/ci_scripts.py
+++ b/scripts/rules/ci_scripts.py
@@ -101,6 +101,7 @@ def shellcheck_failures(config: CiScripts, root: Path) -> set[str] | None:
         cwd=root,
         capture_output=True,
         text=True,
+        check=False,
     )
     return {line.split(":", 1)[0] for line in result.stdout.splitlines() if ":" in line}
 
@@ -177,24 +178,25 @@ def compare(registry: Registry, findings: Findings, root: Path) -> list[Violatio
             "fix what `shellcheck <script>` reports",
         ),
     )
-    violations = []
+    violations: list[Violation] = []
     for check, label, found, baseline_path, fix in checks:
         if found is None:
             continue
         rule_id = _rule_for(registry, baseline_path, check)
         baseline = _baseline(root, baseline_path)
-        for entry in sorted(found - baseline):
-            violations.append(Violation(rule_id, "ci-scripts", f"{label} {entry}", fix))
-        for entry in sorted(baseline - found):
-            violations.append(
-                Violation(
-                    rule_id,
-                    "ci-scripts",
-                    f"baseline entry no longer applies: {entry}",
-                    f"remove it from {baseline_path} and lower the rule's "
-                    "baseline count",
-                )
+        violations.extend(
+            Violation(rule_id, "ci-scripts", f"{label} {entry}", fix)
+            for entry in sorted(found - baseline)
+        )
+        violations.extend(
+            Violation(
+                rule_id,
+                "ci-scripts",
+                f"baseline entry no longer applies: {entry}",
+                f"remove it from {baseline_path} and lower the rule's baseline count",
             )
+            for entry in sorted(baseline - found)
+        )
     return violations
 
 
diff --git a/scripts/rules/discover.py b/scripts/rules/discover.py
index 152ec9469..165c05a75 100644
--- a/scripts/rules/discover.py
+++ b/scripts/rules/discover.py
@@ -61,7 +61,7 @@ def _discovered_tests(registry: Registry, root: Path) -> set[str]:
 
 def discover_hidden(registry: Registry, root: Path) -> list[Violation]:
     """Return a hidden-rule violation for each check no rule references or ignores."""
-    violations = []
+    violations: list[Violation] = []
     rules = registry.rules
 
     # Quality guards registered in the runner.
@@ -69,14 +69,14 @@ def discover_hidden(registry: Registry, root: Path) -> list[Violation]:
     registered = {
         r.enforcer.get("name") for r in rules if r.enforcer.kind is Kind.QUALITY_GUARD
     }
-    for name in names:
-        if name not in registered:
-            violations.append(
-                _hidden(
-                    f"quality guard '{name}' in {DEFAULT_RUNNER} has no rule",
-                    'add a [[rule]] with enforcer.kind = "quality-guard"',
-                )
-            )
+    violations.extend(
+        _hidden(
+            f"quality guard '{name}' in {DEFAULT_RUNNER} has no rule",
+            'add a [[rule]] with enforcer.kind = "quality-guard"',
+        )
+        for name in names
+        if name not in registered
+    )
 
     # Ruff: format checks in CI, explicitly selected codes, per-file ignores.
     ruff_rules = [r for r in rules if r.enforcer.kind is Kind.RUFF]
@@ -99,27 +99,27 @@ def discover_hidden(registry: Registry, root: Path) -> list[Violation]:
         if r.enforcer.get("mode") == "lint"
         for c in r.enforcer.get("codes", [])
     }
-    for code in list(lint.get("select", [])) + list(lint.get("extend-select", [])):
-        if code not in lint_codes:
-            violations.append(
-                _hidden(
-                    f"ruff selects '{code}' but no rule describes it",
-                    "add the code to a ruff lint rule",
-                )
-            )
+    violations.extend(
+        _hidden(
+            f"ruff selects '{code}' but no rule describes it",
+            "add the code to a ruff lint rule",
+        )
+        for code in list(lint.get("select", [])) + list(lint.get("extend-select", []))
+        if code not in lint_codes
+    )
     ignore_patterns = {
         r.enforcer.get("pattern")
         for r in ruff_rules
         if r.enforcer.get("mode") == "per-file-ignore"
     }
-    for pattern in lint.get("per-file-ignores", {}):
-        if pattern not in ignore_patterns:
-            violations.append(
-                _hidden(
-                    f"ruff per-file-ignores '{pattern}' has no rule",
-                    "add a ruff per-file-ignore rule explaining the exemption",
-                )
-            )
+    violations.extend(
+        _hidden(
+            f"ruff per-file-ignores '{pattern}' has no rule",
+            "add a ruff per-file-ignore rule explaining the exemption",
+        )
+        for pattern in lint.get("per-file-ignores", {})
+        if pattern not in ignore_patterns
+    )
 
     # mypy scope.
     covered = {
@@ -128,14 +128,14 @@ def discover_hidden(registry: Registry, root: Path) -> list[Violation]:
         if r.enforcer.kind is Kind.MYPY
         for p in r.enforcer.get("paths", [])
     }
-    for path in mypy_files(root):
-        if path not in covered:
-            violations.append(
-                _hidden(
-                    f"mypy checks '{path}' but no rule describes it",
-                    "add it to a mypy rule's paths",
-                )
-            )
+    violations.extend(
+        _hidden(
+            f"mypy checks '{path}' but no rule describes it",
+            "add it to a mypy rule's paths",
+        )
+        for path in mypy_files(root)
+        if path not in covered
+    )
 
     # Guard-style tests.
     registered_nodes = _registered_nodes(registry)
@@ -143,28 +143,28 @@ def discover_hidden(registry: Registry, root: Path) -> list[Violation]:
         split_node(i.target)[0] + "::" + split_node(i.target)[1]
         for i in registry.discovery.ignore_tests
     }
-    for node in sorted(
-        _discovered_tests(registry, root) - registered_nodes - ignored_tests
-    ):
-        violations.append(
-            _hidden(
-                f"guard test {node} is not referenced by any rule",
-                "add it to a pytest rule's nodes, or to discovery.ignore_tests "
-                "with a reason",
-            )
+    violations.extend(
+        _hidden(
+            f"guard test {node} is not referenced by any rule",
+            "add it to a pytest rule's nodes, or to discovery.ignore_tests "
+            "with a reason",
         )
+        for node in sorted(
+            _discovered_tests(registry, root) - registered_nodes - ignored_tests
+        )
+    )
 
     # CI jobs.
     referenced_jobs = {(ref.workflow, ref.job) for r in rules for ref in r.ci}
     ignored_jobs = {i.target for i in registry.discovery.ignore_jobs}
     for workflow in registry.discovery.workflows:
-        for job_id in workflow_jobs(root / workflow)[0]:
-            if (workflow, job_id) not in referenced_jobs and job_id not in ignored_jobs:
-                violations.append(
-                    _hidden(
-                        f"CI job '{job_id}' in {workflow} enforces no registered rule",
-                        "reference it from a rule's [[rule.ci]], or add it to "
-                        "discovery.ignore_jobs with a reason",
-                    )
-                )
+        violations.extend(
+            _hidden(
+                f"CI job '{job_id}' in {workflow} enforces no registered rule",
+                "reference it from a rule's [[rule.ci]], or add it to "
+                "discovery.ignore_jobs with a reason",
+            )
+            for job_id in workflow_jobs(root / workflow)[0]
+            if (workflow, job_id) not in referenced_jobs and job_id not in ignored_jobs
+        )
     return violations
diff --git a/scripts/rules/render.py b/scripts/rules/render.py
index 68002382e..a6d5b639d 100644
--- a/scripts/rules/render.py
+++ b/scripts/rules/render.py
@@ -197,7 +197,7 @@ def section(title: str, items: list[str]) -> None:
             )
         out.append("")
         for chunk in _mermaid_chunks(group):
-            out += chunk + [""]
+            out += [*chunk, ""]
     return "\n".join(out).rstrip() + "\n"
 
 
diff --git a/scripts/rules/resolve.py b/scripts/rules/resolve.py
index 78a41a2d8..f98207c95 100644
--- a/scripts/rules/resolve.py
+++ b/scripts/rules/resolve.py
@@ -125,16 +125,16 @@ def guard_names(root: Path, runner: str = DEFAULT_RUNNER) -> list[str] | None:
             and target.id == "GUARDS"
             and isinstance(value, ast.Tuple)
         ):
-            names = []
-            for element in value.elts:
+            return [
+                element.elts[0].value
+                for element in value.elts
                 if (
                     isinstance(element, ast.Tuple)
                     and element.elts
                     and isinstance(element.elts[0], ast.Constant)
                     and isinstance(element.elts[0].value, str)
-                ):
-                    names.append(element.elts[0].value)
-            return names
+                )
+            ]
     return []
 
 
@@ -372,7 +372,7 @@ def _resolve_workflow_job(rule: Rule, root: Path) -> list[Violation]:
     Kind.WORKFLOW_JOB: _resolve_workflow_job,
     Kind.DOCS_GUARD: _resolve_file_field("doc"),
     Kind.LLM_REVIEW: _resolve_file_field("prompt"),
-    Kind.NONE: lambda rule, root: [],
+    Kind.NONE: lambda _rule, _root: [],
 }
 
 
@@ -522,14 +522,17 @@ def _test_coverage(
                         "add it to what the job runs, or move the test",
                     )
                 )
-    if project and job.matrix:
-        if not any(project in values for values in job.matrix.values()):
-            violations.append(
-                Violation(
-                    rule_id,
-                    check,
-                    f"project {project} is not in the matrix of job '{job.id}'",
-                    "add the project to the job matrix",
-                )
+    if (
+        project
+        and job.matrix
+        and not any(project in values for values in job.matrix.values())
+    ):
+        violations.append(
+            Violation(
+                rule_id,
+                check,
+                f"project {project} is not in the matrix of job '{job.id}'",
+                "add the project to the job matrix",
             )
+        )
     return violations
diff --git a/scripts/rules/tests/test_guard.py b/scripts/rules/tests/test_guard.py
index 0c5773ed9..83f313147 100644
--- a/scripts/rules/tests/test_guard.py
+++ b/scripts/rules/tests/test_guard.py
@@ -5,6 +5,7 @@
 import subprocess
 import unittest
 from datetime import date
+from typing import ClassVar
 
 from scripts.rules.baseline import check_baselines
 from scripts.rules.load import load_text
@@ -342,7 +343,7 @@ def test_proof_files_must_exist(self) -> None:
 
 
 class ProofCiTest(unittest.TestCase):
-    PROOF_FILES = {
+    PROOF_FILES: ClassVar[dict[str, str]] = {
         "rules/fixtures/bad.py": "import sqlalchemy\n",
         "rules/fixtures/good.py": "x = 1\n",
     }
diff --git a/scripts/rules/validate.py b/scripts/rules/validate.py
index 94f6824c9..9fffbb5a4 100644
--- a/scripts/rules/validate.py
+++ b/scripts/rules/validate.py
@@ -87,15 +87,15 @@ def _check_fields(
                     f"make it a {expected}",
                 )
             )
-    for key in sorted(set(fields) - set(required) - set(optional)):
-        violations.append(
-            Violation(
-                rule.id,
-                "schema",
-                f"unknown key '{key}' in {where}",
-                f"remove it; allowed: {sorted({**required, **optional})}",
-            )
+    violations.extend(
+        Violation(
+            rule.id,
+            "schema",
+            f"unknown key '{key}' in {where}",
+            f"remove it; allowed: {sorted({**required, **optional})}",
         )
+        for key in sorted(set(fields) - set(required) - set(optional))
+    )
     return violations
 
 
diff --git a/scripts/rules/workflows.py b/scripts/rules/workflows.py
index 5c7c039b4..71ae03b13 100644
--- a/scripts/rules/workflows.py
+++ b/scripts/rules/workflows.py
@@ -65,9 +65,13 @@ def _strip_comment(line: str) -> str:
             in_single = not in_single
         elif char == '"' and not in_single:
             in_double = not in_double
-        elif char == "#" and not in_single and not in_double:
-            if index == 0 or line[index - 1].isspace():
-                return line[:index].rstrip()
+        elif (
+            char == "#"
+            and not in_single
+            and not in_double
+            and (index == 0 or line[index - 1].isspace())
+        ):
+            return line[:index].rstrip()
     return line.rstrip()
 
 
@@ -130,7 +134,7 @@ def _inline_list(value: str) -> tuple[str, ...]:
     return tuple(_unquote(item) for item in inner.split(",") if item.strip())
 
 
-def _parse_job(job_id: str, lines: list[str], job_indent: int) -> JobBlock:
+def _parse_job(job_id: str, lines: list[str]) -> JobBlock:
     name = ""
     uses = ""
     step_uses: list[str] = []
@@ -151,9 +155,13 @@ def _parse_job(job_id: str, lines: list[str], job_indent: int) -> JobBlock:
         match = _KEY.match(line)
         if not match:
             item = _LIST_ITEM.match(line)
-            if in_steps and item and item_indent is not None:
-                if len(item.group(1)) == item_indent:
-                    step_index += 1
+            if (
+                in_steps
+                and item
+                and item_indent is not None
+                and len(item.group(1)) == item_indent
+            ):
+                step_index += 1
             index += 1
             continue
         leading, dash, key, value = match.groups()
@@ -275,12 +283,12 @@ def parse_jobs(text: str) -> tuple[dict[str, JobBlock], list[str]]:
         match = re.match(rf"^ {{{job_indent}}}([A-Za-z0-9_-]+):\s*$", line)
         if match and _indent(line) == job_indent:
             if current:
-                jobs[current] = _parse_job(current, current_lines, job_indent)
+                jobs[current] = _parse_job(current, current_lines)
             current, current_lines = match.group(1), []
         elif line.strip() and _indent(line) == job_indent:
             problems.append(f"unexpected line at job level: {line.strip()!r}")
         elif current:
             current_lines.append(line)
     if current:
-        jobs[current] = _parse_job(current, current_lines, job_indent)
+        jobs[current] = _parse_job(current, current_lines)
     return jobs, problems
diff --git a/scripts/smoke_test_local_boot.py b/scripts/smoke_test_local_boot.py
index 8aa3cdde8..d056de017 100755
--- a/scripts/smoke_test_local_boot.py
+++ b/scripts/smoke_test_local_boot.py
@@ -64,24 +64,22 @@ def main() -> int:
     On failure print the app's captured stdout and stderr; always stop the app.
     """
     port = find_free_port()
-    stdout_file = tempfile.NamedTemporaryFile(
+    with tempfile.NamedTemporaryFile(
         mode="w+",
         encoding="utf-8",
         delete=False,
         prefix="policyengine-api-boot-",
         suffix=".stdout.log",
-    )
-    stderr_file = tempfile.NamedTemporaryFile(
+    ) as stdout_file:
+        stdout_path = Path(stdout_file.name)
+    with tempfile.NamedTemporaryFile(
         mode="w+",
         encoding="utf-8",
         delete=False,
         prefix="policyengine-api-boot-",
         suffix=".stderr.log",
-    )
-    stdout_path = Path(stdout_file.name)
-    stderr_path = Path(stderr_file.name)
-    stdout_file.close()
-    stderr_file.close()
+    ) as stderr_file:
+        stderr_path = Path(stderr_file.name)
 
     env = os.environ.copy()
     env["FLASK_DEBUG"] = "1"
diff --git a/tests/conftest.py b/tests/conftest.py
index 7b77c0c8f..62a590559 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -34,4 +34,4 @@ def api_client(mock_v2_runtime_settings):
     from policyengine_api.api import app
 
     app.config["TESTING"] = True
-    yield app.test_client()
+    return app.test_client()
diff --git a/tests/contract/helpers.py b/tests/contract/helpers.py
index 6a04d595c..e8db2dddf 100644
--- a/tests/contract/helpers.py
+++ b/tests/contract/helpers.py
@@ -25,7 +25,7 @@ def assert_subset(actual: Any, expected: Any) -> None:
     if isinstance(expected, list):
         assert isinstance(actual, list)
         assert len(actual) >= len(expected)
-        for actual_value, expected_value in zip(actual, expected):
+        for actual_value, expected_value in zip(actual, expected, strict=False):
             assert_subset(actual_value, expected_value)
         return
 
diff --git a/tests/contract/test_policy_v2_compatibility.py b/tests/contract/test_policy_v2_compatibility.py
index 727b0dae6..9365efa0c 100644
--- a/tests/contract/test_policy_v2_compatibility.py
+++ b/tests/contract/test_policy_v2_compatibility.py
@@ -54,7 +54,7 @@ def test_app_v2_reform_label_maps_to_association_name_only() -> None:
 
 
 def test_core_policy_request_rejects_association_presentation_fields() -> None:
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match=r"name\n  Extra inputs are not permitted"):
         PolicyCreateRequest.model_validate(
             {
                 "country_id": "us",
diff --git a/tests/contract/test_v1_route_contracts.py b/tests/contract/test_v1_route_contracts.py
index 6d7455266..9326f965c 100644
--- a/tests/contract/test_v1_route_contracts.py
+++ b/tests/contract/test_v1_route_contracts.py
@@ -109,7 +109,7 @@ def to_dict(self):
 
 
 class _EconomyService:
-    def get_budget_window_economic_impact(self, **kwargs):
+    def get_budget_window_economic_impact(self, **_kwargs):
         return _BudgetWindowEconomicImpactResult.completed(
             {"kind": "budgetWindow", "windowSize": 1}
         )
@@ -257,7 +257,7 @@ def _json_payload(contract: ContractRequest) -> dict | None:
 def _fake_country():
     return SimpleNamespace(
         metadata={},
-        calculate=lambda household, policy: {
+        calculate=lambda _household, policy: {
             "people": {"you": {"age": {"2026": 40}}},
             "policy": policy,
         },
diff --git a/tests/fixtures/libs/simulation_entrypoint.py b/tests/fixtures/libs/simulation_entrypoint.py
index 6cbdc5961..06fa98f25 100644
--- a/tests/fixtures/libs/simulation_entrypoint.py
+++ b/tests/fixtures/libs/simulation_entrypoint.py
@@ -159,7 +159,7 @@
 
 def create_mock_httpx_response(
     status_code: int = 200,
-    json_data: dict = None,
+    json_data: dict | None = None,
     headers: dict | None = None,
 ):
     """Build a mock httpx response for the Simulation Entrypoint client tests.
diff --git a/tests/fixtures/services/economy_service.py b/tests/fixtures/services/economy_service.py
index 418def7ce..adbd97916 100644
--- a/tests/fixtures/services/economy_service.py
+++ b/tests/fixtures/services/economy_service.py
@@ -106,7 +106,7 @@ def mock_policyengine_version():
 def mock_policy_service():
     """Mock the ORM-facing PolicyService with decoded JSON objects."""
     mock_service = MagicMock()
-    mock_service.get_policy_json.side_effect = lambda country_id, policy_id: (
+    mock_service.get_policy_json.side_effect = lambda _country_id, policy_id: (
         json.loads(MOCK_REFORM_POLICY_JSON)
         if policy_id == MOCK_POLICY_ID
         else json.loads(MOCK_BASELINE_POLICY_JSON)
diff --git a/tests/integration/test_alembic_mysql_lifecycle.py b/tests/integration/test_alembic_mysql_lifecycle.py
index 6817297b0..567d70f7e 100644
--- a/tests/integration/test_alembic_mysql_lifecycle.py
+++ b/tests/integration/test_alembic_mysql_lifecycle.py
@@ -224,7 +224,7 @@ def test_household_mirror_event_uses_mysql_json_representation(monkeypatch):
     # Keep bundle discovery outside this real MySQL JSON and event contract.
     monkeypatch.setattr(
         "policyengine_api.services.household_service.normalize_spm_selection",
-        lambda country_id, selection: dict(resolved_spm),
+        lambda _country_id, _selection: dict(resolved_spm),
     )
 
     try:
diff --git a/tests/integration/test_alembic_v2_lifecycle.py b/tests/integration/test_alembic_v2_lifecycle.py
index b62ef16c1..9c1a28701 100644
--- a/tests/integration/test_alembic_v2_lifecycle.py
+++ b/tests/integration/test_alembic_v2_lifecycle.py
@@ -669,7 +669,7 @@ def test_upgrade_to_head_validates_the_resulting_schema_against_metadata() -> No
 
         with pytest.raises(
             V2MigrationTargetError,
-            match="v2 head schema.*unreviewed_runtime_table",
+            match=r"v2 head schema.*unreviewed_runtime_table",
         ):
             command.upgrade(config, "head")
 
@@ -837,34 +837,32 @@ def test_baseline_region_default_enforces_same_model_dataset() -> None:
                 },
             )
 
-        with pytest.raises(sa.exc.IntegrityError):
-            with engine.begin() as connection:
-                connection.execute(
-                    text(
-                        "INSERT INTO regions "
-                        "(id, code, label, region_type, requires_filter, "
-                        "tax_benefit_model_id, default_dataset_id) "
-                        "VALUES (:id, 'state/ca', 'California', 'state', false, "
-                        ":model_id, :dataset_id)"
-                    ),
-                    {
-                        "id": uuid4(),
-                        "model_id": first_model_id,
-                        "dataset_id": second_dataset_id,
-                    },
-                )
+        with pytest.raises(sa.exc.IntegrityError), engine.begin() as connection:
+            connection.execute(
+                text(
+                    "INSERT INTO regions "
+                    "(id, code, label, region_type, requires_filter, "
+                    "tax_benefit_model_id, default_dataset_id) "
+                    "VALUES (:id, 'state/ca', 'California', 'state', false, "
+                    ":model_id, :dataset_id)"
+                ),
+                {
+                    "id": uuid4(),
+                    "model_id": first_model_id,
+                    "dataset_id": second_dataset_id,
+                },
+            )
 
-        with pytest.raises(sa.exc.IntegrityError):
-            with engine.begin() as connection:
-                connection.execute(
-                    text(
-                        "INSERT INTO datasets "
-                        "(id, name, year, is_output_dataset, "
-                        "tax_benefit_model_id) "
-                        "VALUES (:id, 'missing-output-path', 2024, true, :model_id)"
-                    ),
-                    {"id": uuid4(), "model_id": first_model_id},
-                )
+        with pytest.raises(sa.exc.IntegrityError), engine.begin() as connection:
+            connection.execute(
+                text(
+                    "INSERT INTO datasets "
+                    "(id, name, year, is_output_dataset, "
+                    "tax_benefit_model_id) "
+                    "VALUES (:id, 'missing-output-path', 2024, true, :model_id)"
+                ),
+                {"id": uuid4(), "model_id": first_model_id},
+            )
     finally:
         with engine.begin() as connection:
             connection.execute(
diff --git a/tests/integration/test_budget_window_in_flight_dedupe.py b/tests/integration/test_budget_window_in_flight_dedupe.py
index b6c5c64bd..2e2006786 100644
--- a/tests/integration/test_budget_window_in_flight_dedupe.py
+++ b/tests/integration/test_budget_window_in_flight_dedupe.py
@@ -65,7 +65,7 @@ def test_budget_window_in_flight_dedupe_uses_existing_batch_without_live_db(
     monkeypatch.setattr(
         EconomyService,
         "_build_budget_window_batch_payload",
-        lambda self, **kwargs: {
+        lambda _self, **kwargs: {
             "country_id": "us",
             "start_year": kwargs["start_year"],
             "window_size": kwargs["window_size"],
diff --git a/tests/integration/test_mysql_household_spm_dual_write.py b/tests/integration/test_mysql_household_spm_dual_write.py
index 20e749715..d76a99a50 100644
--- a/tests/integration/test_mysql_household_spm_dual_write.py
+++ b/tests/integration/test_mysql_household_spm_dual_write.py
@@ -104,7 +104,8 @@ def source_receipt(self, creation):
         with self.mysql_sessions() as session:
             source = session.get(V1Household, creation.household.id)
             event = session.get(HouseholdMirrorEvent, creation.mirror_event_id)
-            assert source is not None and event is not None
+            assert source is not None
+            assert event is not None
             return {
                 "source_id": source.id,
                 "household_json": deepcopy(source.household_json),
@@ -213,7 +214,8 @@ def test_spm_source_event_and_postgres_retry_keep_exact_persisted_identity(
     ]
     if value == 0.04 + 3 / 1_000_000:
         assert repr(value) == "0.040003000000000004"
-        assert stored_value == 0.040003 and stored_value != value
+        assert stored_value == 0.040003
+        assert stored_value != value
     record_property("input_value", repr(value))
     record_property("mysql_household_json", raw_json)
     record_property("mysql_source_receipt", json.dumps(before, sort_keys=True))
@@ -250,18 +252,22 @@ def transaction(self):
 
     first = databases.mirror(creation, require_pending=True)
     replay = databases.mirror(creation)
-    assert first.household_created and first.mapping_created
+    assert first.household_created
+    assert first.mapping_created
     assert replay.household_id == first.household_id
-    assert not replay.household_created and not replay.mapping_created
+    assert not replay.household_created
+    assert not replay.mapping_created
     after, completed_at = databases.source_receipt(creation)
-    assert after == before and completed_at is not None
+    assert after == before
+    assert completed_at is not None
 
     # A repeated create is a new immutable legacy source with one shared content row.
     retried_creation = databases.create(value=value, spm=NATIONAL_SPM)
     retried_mirror = databases.mirror(retried_creation)
     assert retried_creation.household.id != creation.household.id
     assert retried_mirror.household_id == first.household_id
-    assert not retried_mirror.household_created and retried_mirror.mapping_created
+    assert not retried_mirror.household_created
+    assert retried_mirror.mapping_created
     with databases.postgres_sessions() as session:
         destination = session.get(Household, first.household_id)
         assert destination is not None
@@ -314,9 +320,11 @@ def test_legacy_absence_and_distinct_spm_selections_keep_distinct_content(databa
     assert len(destination_ids) == 4
     with databases.postgres_sessions() as session:
         saved_legacy = session.get(Household, legacy_result.household_id)
-        assert saved_legacy is not None and "spm" not in saved_legacy.household_data
+        assert saved_legacy is not None
+        assert "spm" not in saved_legacy.household_data
     saved_source = databases.source.get_household("us", legacy.id)
-    assert saved_source is not None and "spm" not in saved_source.household_json
+    assert saved_source is not None
+    assert "spm" not in saved_source.household_json
 
 
 def test_a_creation_that_sends_no_selection_persists_and_mirrors_without_one(
diff --git a/tests/integration/test_v1_policy_dual_write.py b/tests/integration/test_v1_policy_dual_write.py
index 42d59e303..5c026d112 100644
--- a/tests/integration/test_v1_policy_dual_write.py
+++ b/tests/integration/test_v1_policy_dual_write.py
@@ -110,7 +110,7 @@ def _create_v1(
     )
 
 
-@pytest.mark.parametrize("country_id", ("us", "uk"))
+@pytest.mark.parametrize("country_id", ["us", "uk"])
 def test_both_commits_and_interrupted_response_retry_resolve_one_mapping(
     country_id: str,
     disposable_v1_database_url: str,
diff --git a/tests/integration/test_v2_household_persistence.py b/tests/integration/test_v2_household_persistence.py
index 225788454..0869cffb5 100644
--- a/tests/integration/test_v2_household_persistence.py
+++ b/tests/integration/test_v2_household_persistence.py
@@ -205,13 +205,16 @@ def simulated_collision(command) -> CanonicalHouseholdContent:
                 content_hash=original_identity.content_hash,
             )
 
-        with Session(engine) as session, session.begin():
-            with pytest.raises(HouseholdContentHashCollisionError):
-                create_normalized_household(
-                    session,
-                    changed,
-                    canonicalizer=simulated_collision,
-                )
+        with (
+            Session(engine) as session,
+            session.begin(),
+            pytest.raises(HouseholdContentHashCollisionError),
+        ):
+            create_normalized_household(
+                session,
+                changed,
+                canonicalizer=simulated_collision,
+            )
 
         with Session(engine) as session:
             stored = session.get(Household, first.household_id)
@@ -243,9 +246,12 @@ def test_legacy_mappings_are_many_to_one_and_conflicts_roll_back() -> None:
         assert retry.mapping_created is False
 
         conflicting = first.model_copy(update={"label": "Changed source label"})
-        with Session(engine) as session, session.begin():
-            with pytest.raises(LegacyHouseholdMappingIntegrityError):
-                mirror_legacy_household_in_session(session, conflicting)
+        with (
+            Session(engine) as session,
+            session.begin(),
+            pytest.raises(LegacyHouseholdMappingIntegrityError),
+        ):
+            mirror_legacy_household_in_session(session, conflicting)
 
         with Session(engine) as session:
             mappings = session.scalars(
@@ -335,11 +341,10 @@ def test_content_edit_creates_replacement_and_reassigns_named_association() -> N
             Household.__table__.columns.keys()
         )
 
-        with pytest.raises(IntegrityError):
-            with sessions.begin() as session:
-                session.execute(
-                    delete(Household).where(Household.id == original.household_id)
-                )
+        with pytest.raises(IntegrityError), sessions.begin() as session:
+            session.execute(
+                delete(Household).where(Household.id == original.household_id)
+            )
 
         for association_id in (first.id, duplicate.id):
             association_service.delete_user_household(
diff --git a/tests/integration/test_v2_policy_persistence.py b/tests/integration/test_v2_policy_persistence.py
index 4ca019529..b53538ddd 100644
--- a/tests/integration/test_v2_policy_persistence.py
+++ b/tests/integration/test_v2_policy_persistence.py
@@ -199,13 +199,16 @@ def simulated_collision(
                 content_hash=stored.content_hash,
             )
 
-        with Session(engine) as session, session.begin():
-            with pytest.raises(PolicyContentHashCollisionError):
-                create_resolved_policy(
-                    session,
-                    changed,
-                    canonicalizer=simulated_collision,
-                )
+        with (
+            Session(engine) as session,
+            session.begin(),
+            pytest.raises(PolicyContentHashCollisionError),
+        ):
+            create_resolved_policy(
+                session,
+                changed,
+                canonicalizer=simulated_collision,
+            )
 
         with Session(engine) as session:
             values = session.scalars(
@@ -316,14 +319,17 @@ def test_changed_hash_for_one_legacy_identity_rolls_back_without_mutation() -> N
                 "policy_json": {parameter_name: {"2026": 0.3}},
             }
         )
-        with pytest.raises(LegacyPolicyMappingIntegrityError, match="different"):
-            with Session(engine) as session, session.begin():
-                mirror_legacy_policy_in_session(
-                    session,
-                    changed,
-                    running_policyengine_version="5.2.0",
-                    country_package_versions={"us": "1.0.0"},
-                )
+        with (
+            pytest.raises(LegacyPolicyMappingIntegrityError, match="different"),
+            Session(engine) as session,
+            session.begin(),
+        ):
+            mirror_legacy_policy_in_session(
+                session,
+                changed,
+                running_policyengine_version="5.2.0",
+                country_package_versions={"us": "1.0.0"},
+            )
 
         with Session(engine) as session:
             mapping = session.scalar(
@@ -434,9 +440,12 @@ def test_child_insert_failure_rolls_back_the_policy_and_all_values() -> None:
             invalid = _command(model.id, version.id, uuid4())
             content_hash = canonicalize_policy(invalid).content_hash
 
-        with pytest.raises(IntegrityError):
-            with Session(engine) as session, session.begin():
-                create_resolved_policy(session, invalid)
+        with (
+            pytest.raises(IntegrityError),
+            Session(engine) as session,
+            session.begin(),
+        ):
+            create_resolved_policy(session, invalid)
 
         with Session(engine) as session:
             policy_count = session.scalar(
diff --git a/tests/integration/test_v2_user_identity_persistence.py b/tests/integration/test_v2_user_identity_persistence.py
index b8658b9ae..302f2b2f4 100644
--- a/tests/integration/test_v2_user_identity_persistence.py
+++ b/tests/integration/test_v2_user_identity_persistence.py
@@ -337,7 +337,8 @@ def upgrade(_index: int):
         ).all()
         user = session.get(User, browser.user_id)
     assert [row.user_id for row in identities] == [browser.user_id]
-    assert user is not None and user.user_type == "standard"
+    assert user is not None
+    assert user.user_type == "standard"
 
 
 def test_concurrent_first_upgrades_from_two_browsers_share_one_account(
@@ -484,9 +485,12 @@ def test_a_browser_write_after_its_merge_starts_a_new_unauthenticated_user(
         merged_policy = session.get(UserPolicy, merged_policy_id)
         new_policy = session.get(UserPolicy, new_policy_id)
         browser_user = session.get(User, browser.user_id)
-    assert merged_policy is not None and merged_policy.user_id == alice_id
-    assert new_policy is not None and new_policy.user_id == browser.user_id
-    assert browser_user is not None and browser_user.user_type == "unauthenticated"
+    assert merged_policy is not None
+    assert merged_policy.user_id == alice_id
+    assert new_policy is not None
+    assert new_policy.user_id == browser.user_id
+    assert browser_user is not None
+    assert browser_user.user_type == "unauthenticated"
 
 
 def test_a_browser_account_deletion_never_deletes_its_converted_user(
@@ -509,8 +513,10 @@ def test_a_browser_account_deletion_never_deletes_its_converted_user(
     with sessions() as session:
         user = session.get(User, browser.user_id)
         policy = session.get(UserPolicy, policy_id)
-    assert user is not None and user.user_type == "standard"
-    assert policy is not None and policy.user_id == browser.user_id
+    assert user is not None
+    assert user.user_type == "standard"
+    assert policy is not None
+    assert policy.user_id == browser.user_id
 
 
 def test_upgrade_never_locks_a_standard_user_named_by_the_header(sessions) -> None:
@@ -566,9 +572,8 @@ def test_unauthenticated_users_are_written_only_with_their_id(sessions) -> None:
         user.last_name,
         user.email,
     ) == ("unauthenticated", None, None, None, None)
-    with pytest.raises(IntegrityError):
-        with sessions.begin() as session:
-            session.add(User(user_type="standard"))
+    with pytest.raises(IntegrityError), sessions.begin() as session:
+        session.add(User(user_type="standard"))
 
 
 def test_non_finite_numbers_never_reach_jsonb(sessions) -> None:
@@ -598,7 +603,8 @@ def test_non_finite_numbers_never_reach_jsonb(sessions) -> None:
 
     with sessions() as session:
         row = session.get(UserReportAssociation, stored.id)
-    assert row is not None and row.provisions == [provision]
+    assert row is not None
+    assert row.provisions == [provision]
 
 
 def test_report_budget_windows_persist_within_the_api_window_limit(sessions) -> None:
@@ -613,19 +619,19 @@ def test_report_budget_windows_persist_within_the_api_window_limit(sessions) ->
     )
     with sessions() as session:
         row = session.get(UserReportAssociation, stored.id)
-    assert row is not None and row.budget_window_years == 10
+    assert row is not None
+    assert row.budget_window_years == 10
 
     for out_of_range_years in (1, 76):
-        with pytest.raises(IntegrityError):
-            with sessions.begin() as session:
-                session.add(
-                    UserReportAssociation(
-                        user_id=stored.user_id,
-                        country_id="us",
-                        legacy_report_id=615,
-                        budget_window_years=out_of_range_years,
-                    )
+        with pytest.raises(IntegrityError), sessions.begin() as session:
+            session.add(
+                UserReportAssociation(
+                    user_id=stored.user_id,
+                    country_id="us",
+                    legacy_report_id=615,
+                    budget_window_years=out_of_range_years,
                 )
+            )
 
 
 def test_reference_checks_and_match_simple_composite_keys(sessions) -> None:
@@ -651,9 +657,8 @@ def test_reference_checks_and_match_simple_composite_keys(sessions) -> None:
         UserPolicy(user_id=owner, country_id="ca", legacy_policy_id=1),
         UserPolicy(user_id=owner, country_id="us", policy_id=uuid4()),
     ):
-        with pytest.raises(IntegrityError):
-            with sessions.begin() as session:
-                session.add(invalid)
+        with pytest.raises(IntegrityError), sessions.begin() as session:
+            session.add(invalid)
 
 
 def test_account_deletion_cascades_after_removing_legacy_mappings(sessions) -> None:
@@ -698,7 +703,8 @@ def delete_user(self, subject: str) -> None:
             )
 
 
-def test_qualification_reads_counts_in_a_read_only_transaction(sessions) -> None:
+@pytest.mark.usefixtures("sessions")
+def test_qualification_reads_counts_in_a_read_only_transaction() -> None:
     disposable_url = _disposable_url()
     # The settings loader requires a persistent-looking target; the engine
     # builder substitutes the disposable database, which is all that is read.
diff --git a/tests/integration/test_v2_user_policy_mirroring.py b/tests/integration/test_v2_user_policy_mirroring.py
index a0f667425..a321f7946 100644
--- a/tests/integration/test_v2_user_policy_mirroring.py
+++ b/tests/integration/test_v2_user_policy_mirroring.py
@@ -391,7 +391,8 @@ def test_complete_transaction_rolls_back_and_native_delete_is_isolated() -> None
         model_id, parameter_name = _seed_catalog(sessions)
         reform = _reform(parameter_name, legacy_id=501, source_hash="rollback")
         saved = _saved(legacy_id=601, reform_id=501)
-        with pytest.raises(RuntimeError, match="forced rollback"):
+
+        def mirror_then_fail() -> None:
             with sessions.begin() as session:
                 mirror_legacy_user_policy_in_session(
                     session,
@@ -402,6 +403,9 @@ def test_complete_transaction_rolls_back_and_native_delete_is_isolated() -> None
                 msg = "forced rollback"
                 raise RuntimeError(msg)
 
+        with pytest.raises(RuntimeError, match="forced rollback"):
+            mirror_then_fail()
+
         with sessions() as session:
             assert session.scalar(select(func.count()).select_from(Policy)) == 0
             assert session.scalar(select(func.count()).select_from(UserPolicy)) == 0
diff --git a/tests/to_refactor/python/test_economy_budget_window_routes.py b/tests/to_refactor/python/test_economy_budget_window_routes.py
index 07bbec92a..29b6a4028 100644
--- a/tests/to_refactor/python/test_economy_budget_window_routes.py
+++ b/tests/to_refactor/python/test_economy_budget_window_routes.py
@@ -113,7 +113,7 @@ def test_budget_window_route_requires_integer_window_size(
 
     assert response.status_code == 400
     assert data["status"] == "error"
-    assert "window_size must be an integer" == data["message"]
+    assert data["message"] == "window_size must be an integer"
     mock_get_budget_window_economic_impact.assert_not_called()
 
 
@@ -140,7 +140,7 @@ def test_budget_window_route_rejects_end_year_after_2099(api_client):
 
     assert response.status_code == 400
     assert data["status"] == "error"
-    assert "budget-window end_year must be 2099 or earlier" == data["message"]
+    assert data["message"] == "budget-window end_year must be 2099 or earlier"
 
 
 @patch(
diff --git a/tests/to_refactor/python/test_policy.py b/tests/to_refactor/python/test_policy.py
index 1857bee9a..9e38c1727 100644
--- a/tests/to_refactor/python/test_policy.py
+++ b/tests/to_refactor/python/test_policy.py
@@ -1,4 +1,5 @@
 import json
+from typing import ClassVar
 
 from sqlalchemy import delete
 
@@ -10,9 +11,9 @@
 class TestPolicyCreation:
     # Define the policy to test against
     country_id = "us"
-    policy_json = {"sample_parameter": {"2024-01-01.2025-12-31": True}}
+    policy_json: ClassVar[dict] = {"sample_parameter": {"2024-01-01.2025-12-31": True}}
     label = "dworkin"
-    test_policy = {"data": policy_json, "label": label}
+    test_policy: ClassVar[dict] = {"data": policy_json, "label": label}
     policy_hash = hash_object(policy_json)
 
     """
diff --git a/tests/to_refactor/python/test_user_profile_routes.py b/tests/to_refactor/python/test_user_profile_routes.py
index bfdccc9c9..57a10bdf7 100644
--- a/tests/to_refactor/python/test_user_profile_routes.py
+++ b/tests/to_refactor/python/test_user_profile_routes.py
@@ -1,5 +1,6 @@
 import json
 import time
+from typing import ClassVar
 
 from sqlalchemy import delete, select
 
@@ -14,7 +15,7 @@ class TestUserProfiles:
     # Simulate JS's Date.now()
     user_since = int(time.time())
 
-    test_profile = {
+    test_profile: ClassVar[dict] = {
         "auth0_id": auth0_id,
         "primary_country": primary_country,
         "user_since": user_since,
diff --git a/tests/to_refactor/python/test_validate_country.py b/tests/to_refactor/python/test_validate_country.py
index 389603d37..b2e5a1566 100644
--- a/tests/to_refactor/python/test_validate_country.py
+++ b/tests/to_refactor/python/test_validate_country.py
@@ -4,7 +4,7 @@
 
 
 @validate_country
-def foo(country_id, other):
+def foo(_country_id, _other):
     """Return "bar"; a stand-in view for exercising the decorator.
 
     It must be defined outside the class (or within the test functions themselves)
diff --git a/tests/unit/data/test_congressional_districts.py b/tests/unit/data/test_congressional_districts.py
index e2a819793..b50718259 100644
--- a/tests/unit/data/test_congressional_districts.py
+++ b/tests/unit/data/test_congressional_districts.py
@@ -49,7 +49,7 @@ def test__contains_50_states_plus_dc(self):
         assert len(STATE_CODE_TO_NAME) == 51
 
     def test__contains_all_state_codes_uppercase(self):
-        for code in STATE_CODE_TO_NAME.keys():
+        for code in STATE_CODE_TO_NAME:
             assert code == code.upper()
             assert len(code) == 2
 
diff --git a/tests/unit/data/test_orm_sessions.py b/tests/unit/data/test_orm_sessions.py
index 9b5e699c0..036788077 100644
--- a/tests/unit/data/test_orm_sessions.py
+++ b/tests/unit/data/test_orm_sessions.py
@@ -36,12 +36,15 @@ def test_session_factory_begin_commits_and_rolls_back():
     with factory.begin() as session:
         session.execute(text("INSERT INTO item (id) VALUES (1)"))
 
-    with pytest.raises(RuntimeError, match="stop"):
+    def insert_then_fail() -> None:
         with factory.begin() as session:
             session.execute(text("INSERT INTO item (id) VALUES (2)"))
             msg = "stop"
             raise RuntimeError(msg)
 
+    with pytest.raises(RuntimeError, match="stop"):
+        insert_then_fail()
+
     with factory() as session:
         assert session.scalars(text("SELECT id FROM item ORDER BY id")).all() == [1]
 
diff --git a/tests/unit/data/test_places.py b/tests/unit/data/test_places.py
index fc73e7e56..949bee251 100644
--- a/tests/unit/data/test_places.py
+++ b/tests/unit/data/test_places.py
@@ -20,14 +20,12 @@ def test__given_lowercase_place_code__returns_tuple(self):
         assert fips == "44000"
 
     def test__given_no_hyphen__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid place format"):
             parse_place_code("NJ57000")
-        assert "Invalid place format" in str(exc_info.value)
 
     def test__given_empty_string__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid place format"):
             parse_place_code("")
-        assert "Invalid place format" in str(exc_info.value)
 
 
 class TestValidatePlaceCode:
@@ -40,26 +38,21 @@ def test__given_valid_place_code__no_error(self):
         validate_place_code("TX-35000")
 
     def test__given_invalid_state__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid state in place code"):
             validate_place_code("XX-57000")
-        assert "Invalid state in place code" in str(exc_info.value)
 
     def test__given_non_digit_fips__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid FIPS code"):
             validate_place_code("NJ-abcde")
-        assert "Invalid FIPS code" in str(exc_info.value)
 
     def test__given_short_fips__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid FIPS code"):
             validate_place_code("NJ-5700")
-        assert "Invalid FIPS code" in str(exc_info.value)
 
     def test__given_long_fips__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid FIPS code"):
             validate_place_code("NJ-570001")
-        assert "Invalid FIPS code" in str(exc_info.value)
 
     def test__given_no_hyphen__raises_value_error(self):
-        with pytest.raises(ValueError) as exc_info:
+        with pytest.raises(ValueError, match="Invalid place format"):
             validate_place_code("NJ57000")
-        assert "Invalid place format" in str(exc_info.value)
diff --git a/tests/unit/data/test_v1_database_migration.py b/tests/unit/data/test_v1_database_migration.py
index 2b5d37579..c354e766a 100644
--- a/tests/unit/data/test_v1_database_migration.py
+++ b/tests/unit/data/test_v1_database_migration.py
@@ -186,7 +186,7 @@ def dispose(self):
 
     calls = []
     monkeypatch.setattr(
-        migration, "create_engine", lambda *args, **kwargs: FakeEngine()
+        migration, "create_engine", lambda *_args, **_kwargs: FakeEngine()
     )
     monkeypatch.setattr(
         migration,
@@ -221,13 +221,13 @@ def dispose(self):
 @pytest.mark.parametrize("state", [DatabaseState.UNVERSIONED, DatabaseState.INVALID])
 def test_upgrade_refuses_databases_without_valid_revision_history(monkeypatch, state):
     class FakeConnection:
-        def scalar(self, *args, **kwargs):
+        def scalar(self, *_args, **_kwargs):
             return 1
 
         def execute(self, *args, **kwargs):
             pass
 
-    monkeypatch.setattr(migration, "database_state", lambda connection: state)
+    monkeypatch.setattr(migration, "database_state", lambda _connection: state)
 
     with pytest.raises(RuntimeError, match="no valid Alembic revision"):
         upgrade_database(FakeConnection(), backup_id="verified-backup")
diff --git a/tests/unit/libs/test_auth0_management.py b/tests/unit/libs/test_auth0_management.py
index 668a79b96..0757df37c 100644
--- a/tests/unit/libs/test_auth0_management.py
+++ b/tests/unit/libs/test_auth0_management.py
@@ -31,7 +31,7 @@ def record(request: httpx.Request) -> httpx.Response:
         Auth0ManagementClient(
             Auth0ManagementSettings(**values),
             http_client=httpx.Client(transport=httpx.MockTransport(record)),
-            secret_loader=lambda resource: "loaded-secret",
+            secret_loader=lambda _resource: "loaded-secret",
         ),
         requests,
     )
@@ -149,7 +149,8 @@ def record(request: httpx.Request) -> httpx.Response:
 
     first = build_auth0_user_deleter(environ)
     second = build_auth0_user_deleter(environ)
-    assert first is not None and second is not None
+    assert first is not None
+    assert second is not None
     first.delete_user("auth0|1")
     second.delete_user("auth0|2")
 
diff --git a/tests/unit/libs/test_gateway_auth.py b/tests/unit/libs/test_gateway_auth.py
index 8103c9a69..554d759f5 100644
--- a/tests/unit/libs/test_gateway_auth.py
+++ b/tests/unit/libs/test_gateway_auth.py
@@ -148,15 +148,17 @@ def test__given_secret_manager_failure__then_raises(self):
                 client_secret_resource=CLIENT_SECRET_RESOURCE,
             )
 
-            with patch(
-                "policyengine_api.libs.gateway_auth._load_secret_from_secret_manager",
-                side_effect=RuntimeError("no access"),
-            ):
-                with pytest.raises(
+            with (
+                patch(
+                    "policyengine_api.libs.gateway_auth._load_secret_from_secret_manager",
+                    side_effect=RuntimeError("no access"),
+                ),
+                pytest.raises(
                     GatewayAuthError,
                     match="Failed to load gateway auth client secret",
-                ):
-                    provider.get_token()
+                ),
+            ):
+                provider.get_token()
 
         def test__given_trailing_slash_issuer__then_no_double_slash(self):
             provider = GatewayAuthTokenProvider(
@@ -224,12 +226,14 @@ def test__given_network_error__then_raises_gateway_auth_error(self):
                 client_secret=CLIENT_SECRET,
             )
 
-            with patch(
-                "policyengine_api.libs.gateway_auth.httpx.post",
-                side_effect=httpx.ConnectError("boom"),
+            with (
+                patch(
+                    "policyengine_api.libs.gateway_auth.httpx.post",
+                    side_effect=httpx.ConnectError("boom"),
+                ),
+                pytest.raises(GatewayAuthError),
             ):
-                with pytest.raises(GatewayAuthError):
-                    provider.get_token()
+                provider.get_token()
 
         def test__given_response_without_access_token__then_raises(self):
             provider = GatewayAuthTokenProvider(
@@ -243,12 +247,14 @@ def test__given_response_without_access_token__then_raises(self):
             response.raise_for_status = MagicMock()
             response.json.return_value = {"token_type": "Bearer", "expires_in": 3600}
 
-            with patch(
-                "policyengine_api.libs.gateway_auth.httpx.post",
-                return_value=response,
+            with (
+                patch(
+                    "policyengine_api.libs.gateway_auth.httpx.post",
+                    return_value=response,
+                ),
+                pytest.raises(GatewayAuthError),
             ):
-                with pytest.raises(GatewayAuthError):
-                    provider.get_token()
+                provider.get_token()
 
         def test__given_missing_expires_in__then_raises(self):
             provider = GatewayAuthTokenProvider(
@@ -262,12 +268,14 @@ def test__given_missing_expires_in__then_raises(self):
             response.raise_for_status = MagicMock()
             response.json.return_value = {"access_token": "tok"}
 
-            with patch(
-                "policyengine_api.libs.gateway_auth.httpx.post",
-                return_value=response,
+            with (
+                patch(
+                    "policyengine_api.libs.gateway_auth.httpx.post",
+                    return_value=response,
+                ),
+                pytest.raises(GatewayAuthError),
             ):
-                with pytest.raises(GatewayAuthError):
-                    provider.get_token()
+                provider.get_token()
 
         def test__given_zero_expires_in__then_clamped_to_refresh_margin(self):
             provider = GatewayAuthTokenProvider(
diff --git a/tests/unit/libs/test_simulation_entrypoint.py b/tests/unit/libs/test_simulation_entrypoint.py
index bfe36c7e2..4d8cdf6ae 100644
--- a/tests/unit/libs/test_simulation_entrypoint.py
+++ b/tests/unit/libs/test_simulation_entrypoint.py
@@ -5,6 +5,7 @@
 """
 
 import os
+from typing import ClassVar
 from unittest.mock import patch
 
 import httpx
@@ -13,14 +14,14 @@
 
 os.environ.setdefault("FLASK_DEBUG", "1")
 
-from policyengine_api.constants import (  # noqa: E402
+from policyengine_api.constants import (
     MODAL_EXECUTION_STATUS_COMPLETE,
     MODAL_EXECUTION_STATUS_FAILED,
     MODAL_EXECUTION_STATUS_RUNNING,
     MODAL_EXECUTION_STATUS_SUBMITTED,
     POLICYENGINE_VERSION,
 )
-from policyengine_api.libs.simulation_entrypoint import (  # noqa: E402
+from policyengine_api.libs.simulation_entrypoint import (
     ModalBudgetWindowBatchExecution,
     ModalSimulationExecution,
     SimulationAPIModal,
@@ -28,17 +29,17 @@
     SimulationRunProgress,
     resolve_simulation_entrypoint_url,
 )
-from policyengine_api.observability.identifiers import (  # noqa: E402
+from policyengine_api.observability.identifiers import (
     OBSERVABILITY_ID_HEADER,
 )
-from policyengine_api.request_context import (  # noqa: E402
+from policyengine_api.request_context import (
     REQUEST_ID_HEADER,
     _asgi_observability_id,
     _asgi_request_id,
     current_observability_id,
     start_observability_id,
 )
-from tests.fixtures.libs.simulation_entrypoint import (  # noqa: E402
+from tests.fixtures.libs.simulation_entrypoint import (
     MOCK_BATCH_JOB_ID,
     MOCK_BATCH_POLL_RESPONSE_COMPLETE,
     MOCK_BATCH_POLL_RESPONSE_FAILED,
@@ -60,7 +61,7 @@
     MOCK_WORKER_VERSIONS,
     create_mock_httpx_response,
 )
-from tests.fixtures.spm import INSTALLED_SPM_SELECTION  # noqa: E402
+from tests.fixtures.spm import INSTALLED_SPM_SELECTION
 
 pytest_plugins = ("tests.fixtures.libs.simulation_entrypoint",)
 
@@ -83,9 +84,9 @@
 class RequestRecordingHTTPXClient:
     """Minimal HTTPX-compatible client that executes request event hooks."""
 
-    instances = []
+    instances: ClassVar[list] = []
 
-    def __init__(self, *, event_hooks=None, **kwargs):
+    def __init__(self, *, event_hooks=None, **_kwargs):
         self.event_hooks = event_hooks or {}
         self.requests = []
         type(self).instances.append(self)
@@ -282,7 +283,8 @@ class TestSimulationAPIModal:
     """Tests for the SimulationAPIModal class."""
 
     class TestInit:
-        def test__given_env_var_set__then_uses_env_url(self, mock_httpx_client):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_env_var_set__then_uses_env_url(self):
             # Given
             with patch.dict(
                 "os.environ",
@@ -297,9 +299,8 @@ def test__given_env_var_set__then_uses_env_url(self, mock_httpx_client):
                 # Then
                 assert api.base_url == MOCK_MODAL_BASE_URL
 
-        def test__given_selected_url_not_set__then_fails_startup(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_selected_url_not_set__then_fails_startup(self):
             # Given
             with patch.dict("os.environ", {}, clear=False):
                 import os
@@ -314,8 +315,9 @@ def test__given_selected_url_not_set__then_fails_startup(
                 ):
                     SimulationAPIModal()
 
+        @pytest.mark.usefixtures("mock_httpx_client")
         def test__given_gateway_auth_env_vars__then_attaches_bearer_auth(
-            self, mock_httpx_client, monkeypatch
+            self, monkeypatch
         ):
             from policyengine_api.libs.gateway_auth import GatewayBearerAuth
             from policyengine_api.libs.simulation_entrypoint import httpx as modal_httpx
@@ -330,8 +332,9 @@ def test__given_gateway_auth_env_vars__then_attaches_bearer_auth(
             _, kwargs = modal_httpx.Client.call_args
             assert isinstance(kwargs.get("auth"), GatewayBearerAuth)
 
+        @pytest.mark.usefixtures("mock_httpx_client", "mock_modal_logger")
         def test__given_missing_gateway_auth_env_vars__then_no_auth_attached(
-            self, mock_httpx_client, monkeypatch, mock_modal_logger
+            self, monkeypatch
         ):
             from policyengine_api.libs.simulation_entrypoint import httpx as modal_httpx
 
@@ -349,8 +352,9 @@ def test__given_missing_gateway_auth_env_vars__then_no_auth_attached(
             _, kwargs = modal_httpx.Client.call_args
             assert kwargs.get("auth") is None
 
+        @pytest.mark.usefixtures("mock_httpx_client")
         def test__given_missing_gateway_auth_env_vars_when_required__then_raises(
-            self, mock_httpx_client, monkeypatch
+            self, monkeypatch
         ):
             from policyengine_api.libs.gateway_auth import GatewayAuthError
 
@@ -366,9 +370,8 @@ def test__given_missing_gateway_auth_env_vars_when_required__then_raises(
             with pytest.raises(GatewayAuthError, match="Gateway auth is required"):
                 SimulationAPIModal()
 
-        def test__given_partial_gateway_auth_env_vars__then_raises(
-            self, mock_httpx_client, monkeypatch
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_partial_gateway_auth_env_vars__then_raises(self, monkeypatch):
             from policyengine_api.libs.gateway_auth import GatewayAuthError
 
             monkeypatch.setenv("GATEWAY_AUTH_ISSUER", "https://tenant.auth0.com")
@@ -379,9 +382,8 @@ def test__given_partial_gateway_auth_env_vars__then_raises(
             with pytest.raises(GatewayAuthError):
                 SimulationAPIModal()
 
-        def test__given_client_initialized__then_installs_correlation_hooks(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_client_initialized__then_installs_correlation_hooks(self):
             from policyengine_api.libs.simulation_entrypoint import httpx as modal_httpx
 
             SimulationAPIModal()
@@ -390,8 +392,9 @@ def test__given_client_initialized__then_installs_correlation_hooks(
             assert list(kwargs["event_hooks"]) == ["request"]
             assert len(kwargs["event_hooks"]["request"]) == 1
 
+        @pytest.mark.usefixtures("mock_httpx_client")
         def test__given_client_initialized__then_instruments_explicit_httpx_client(
-            self, mock_httpx_client
+            self,
         ):
             from policyengine_api.libs import simulation_entrypoint as module
 
@@ -404,9 +407,8 @@ def test__given_client_initialized__then_instruments_explicit_httpx_client(
 
             instrument.assert_called_once_with(client.client, runtime)
 
-        def test__given_flask_request__then_hook_uses_current_request_id(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_flask_request__then_hook_uses_current_request_id(self):
             from policyengine_api.libs.simulation_entrypoint import httpx as modal_httpx
 
             SimulationAPIModal()
@@ -424,9 +426,8 @@ def test__given_flask_request__then_hook_uses_current_request_id(
 
             assert request.headers[REQUEST_ID_HEADER] == "flask-request-id"
 
-        def test__given_asgi_request__then_hook_uses_current_correlation_ids(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_asgi_request__then_hook_uses_current_correlation_ids(self):
             from policyengine_api.libs.simulation_entrypoint import httpx as modal_httpx
 
             SimulationAPIModal()
@@ -443,8 +444,9 @@ def test__given_asgi_request__then_hook_uses_current_correlation_ids(
             assert request.headers[REQUEST_ID_HEADER] == "asgi-request-id"
             assert request.headers[OBSERVABILITY_ID_HEADER] == MOCK_OBSERVABILITY_ID
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_no_request_context__then_hook_omits_request_id(
-            self, monkeypatch, mock_modal_logger
+            self, monkeypatch
         ):
             from policyengine_api.libs import simulation_entrypoint as module
 
@@ -470,10 +472,10 @@ def test__given_no_request_context__then_hook_omits_request_id(
                 ),
             ],
         )
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_request_context__then_all_calls_forward_request_id(
             self,
             monkeypatch,
-            mock_modal_logger,
             entrypoint,
             url_env_name,
         ):
@@ -514,10 +516,10 @@ def test__given_request_context__then_all_calls_forward_request_id(
                 for request in requests
             )
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_started_calculation__then_client_preserves_one_observability_id(
             self,
             monkeypatch,
-            mock_modal_logger,
         ):
             from policyengine_api.libs import simulation_entrypoint as module
 
@@ -555,8 +557,9 @@ def test__given_started_calculation__then_client_preserves_one_observability_id(
             {"data_version": "1.77.0"},
         ],
     )
+    @pytest.mark.usefixtures("mock_modal_logger")
     def test__given_dataset_override__then_does_not_post(
-        self, method, override, mock_httpx_client, mock_modal_logger
+        self, method, override, mock_httpx_client
     ):
         api = SimulationAPIModal()
 
@@ -566,10 +569,10 @@ def test__given_dataset_override__then_does_not_post(
         mock_httpx_client.post.assert_not_called()
 
     class TestRun:
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_valid_payload__then_returns_execution_with_job_id(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.post.return_value = create_mock_httpx_response(
@@ -589,10 +592,10 @@ def test__given_valid_payload__then_returns_execution_with_job_id(
             assert execution.resolved_app_name == MOCK_RESOLVED_APP_NAME
             mock_httpx_client.post.assert_called_once()
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_valid_payload__then_posts_to_correct_endpoint(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.post.return_value = create_mock_httpx_response(
@@ -613,10 +616,10 @@ def test__given_valid_payload__then_posts_to_correct_endpoint(
                 "policyengine_version": POLICYENGINE_VERSION,
             }
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_telemetry_payload__then_preserves_non_identity_fields(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.post.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -632,10 +635,10 @@ def test__given_telemetry_payload__then_preserves_non_identity_fields(
                 "capture_mode": "disabled",
             }
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_model_and_bundle_versions__then_translates_payload_for_modal(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.post.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -656,10 +659,10 @@ def test__given_model_and_bundle_versions__then_translates_payload_for_modal(
             assert "model_version" not in posted_payload
             assert "data_version" not in posted_payload
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_api_v1_default_bundle_payload__then_posts_gateway_contract_body(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.post.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -716,10 +719,10 @@ def test__given_api_v1_default_bundle_payload__then_posts_gateway_contract_body(
             assert "model_version" not in posted_payload
             assert "data_version" not in posted_payload
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_http_error__then_raises_exception(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_response = create_mock_httpx_response(
@@ -757,10 +760,10 @@ def test__given_network_error__then_raises_exception(
             assert log_payload["observability_id"] == MOCK_OBSERVABILITY_ID
 
     class TestResolveAppName:
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_country_and_version__then_returns_registered_app(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=200,
@@ -776,10 +779,10 @@ def test__given_country_and_version__then_returns_registered_app(
             assert app_name == MOCK_RESOLVED_APP_NAME
             assert resolved_version == "1.459.0"
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_unknown_version__then_raises_value_error(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=200,
@@ -791,14 +794,14 @@ def test__given_unknown_version__then_raises_value_error(
             api = SimulationAPIModal()
 
             with pytest.raises(
-                ValueError, match="Unknown version 9.9.9 for country us"
+                ValueError, match=r"Unknown version 9\.9\.9 for country us"
             ):
                 api.resolve_app_name("us", "9.9.9")
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_policyengine_version__then_returns_registered_bundle_app(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=200,
@@ -822,10 +825,10 @@ def test__given_policyengine_version__then_returns_registered_bundle_app(
             )
 
     class TestRunBudgetWindowBatch:
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_valid_payload__then_returns_batch_execution(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.post.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -840,10 +843,10 @@ def test__given_valid_payload__then_returns_batch_execution(
             call_args = mock_httpx_client.post.call_args
             assert "/simulate/economy/budget-window" in call_args[0][0]
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_model_and_bundle_versions__then_translates_payload_for_modal(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.post.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -864,10 +867,10 @@ def test__given_model_and_bundle_versions__then_translates_payload_for_modal(
             assert "model_version" not in posted_payload
             assert "data_version" not in posted_payload
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_http_error__then_raises_exception(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_response = create_mock_httpx_response(
                 status_code=400,
@@ -900,10 +903,10 @@ def test__given_network_error__then_raises_exception(
             assert log_payload["observability_id"] == MOCK_OBSERVABILITY_ID
 
     class TestGetExecutionById:
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_running_job__then_returns_running_status(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -920,10 +923,10 @@ def test__given_running_job__then_returns_running_status(
             assert execution.status == MODAL_EXECUTION_STATUS_RUNNING
             assert execution.result is None
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_complete_job__then_returns_result(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -941,10 +944,10 @@ def test__given_complete_job__then_returns_result(
             assert execution.policyengine_bundle == MOCK_POLICYENGINE_BUNDLE
             assert execution.resolved_app_name == MOCK_RESOLVED_APP_NAME
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_failed_job__then_returns_error(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -960,10 +963,10 @@ def test__given_failed_job__then_returns_error(
             assert execution.status == MODAL_EXECUTION_STATUS_FAILED
             assert execution.error == "Simulation timed out"
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_running_job_with_stage_fields__then_reads_run_progress(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -997,10 +1000,10 @@ def test__given_running_job_with_stage_fields__then_reads_run_progress(
                 "segments": {"completed": 19, "total": 20},
             }
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_running_job_without_stage_fields__then_has_no_run_progress(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -1015,10 +1018,10 @@ def test__given_running_job_without_stage_fields__then_has_no_run_progress(
             # Then
             assert execution.run_progress is None
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_only_a_submission_time__then_relays_it(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given - a job on a worker app without stages, after
             # policyengine-sim-api#781 deploys its gateway
@@ -1039,10 +1042,10 @@ def test__given_only_a_submission_time__then_relays_it(
                 "submitted_at": "2026-10-13T12:00:00Z"
             }
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_a_malformed_timestamp__then_drops_the_stage_fields(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -1062,10 +1065,10 @@ def test__given_a_malformed_timestamp__then_drops_the_stage_fields(
             assert execution.status == MODAL_EXECUTION_STATUS_RUNNING
             assert execution.run_progress is None
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_malformed_stage_fields__then_still_returns_status(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -1085,10 +1088,10 @@ def test__given_malformed_stage_fields__then_still_returns_status(
             assert execution.status == MODAL_EXECUTION_STATUS_RUNNING
             assert execution.run_progress is None
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_job_id__then_polls_correct_endpoint(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
@@ -1104,10 +1107,10 @@ def test__given_job_id__then_polls_correct_endpoint(
             call_args = mock_httpx_client.get.call_args
             assert f"/jobs/{MOCK_MODAL_JOB_ID}" in call_args[0][0]
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_unexpected_http_error__then_raises_exception(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=403,
@@ -1144,10 +1147,10 @@ def test__given_unknown_stage__then_keeps_it(self):
             }
 
     class TestGetBudgetWindowBatchById:
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_running_batch__then_returns_running_status(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=202,
@@ -1163,10 +1166,10 @@ def test__given_running_batch__then_returns_running_status(
             assert execution.running_years == ["2027"]
             assert execution.queued_years == ["2028"]
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_complete_batch__then_returns_result(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=200,
@@ -1179,10 +1182,10 @@ def test__given_complete_batch__then_returns_result(
             assert execution.status == MODAL_EXECUTION_STATUS_COMPLETE
             assert execution.result == MOCK_BATCH_POLL_RESPONSE_COMPLETE["result"]
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_failed_batch__then_returns_error(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=500,
@@ -1196,10 +1199,10 @@ def test__given_failed_batch__then_returns_error(
             assert execution.failed_years == ["2027"]
             assert execution.error == "Budget window failed"
 
+        @pytest.mark.usefixtures("mock_modal_logger")
         def test__given_unexpected_http_error__then_raises_exception(
             self,
             mock_httpx_client,
-            mock_modal_logger,
         ):
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=404,
@@ -1225,7 +1228,8 @@ def test__given_network_error__then_raises_exception(
             assert MOCK_BATCH_JOB_ID in log_payload["message"]
 
     class TestGetExecutionId:
-        def test__given_execution__then_returns_job_id(self, mock_httpx_client):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_execution__then_returns_job_id(self):
             # Given
             api = SimulationAPIModal()
             execution = ModalSimulationExecution(
@@ -1240,7 +1244,8 @@ def test__given_execution__then_returns_job_id(self, mock_httpx_client):
             assert execution_id == MOCK_MODAL_JOB_ID
 
     class TestGetExecutionStatus:
-        def test__given_execution__then_returns_status_string(self, mock_httpx_client):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_execution__then_returns_status_string(self):
             # Given
             api = SimulationAPIModal()
             execution = ModalSimulationExecution(
@@ -1255,9 +1260,8 @@ def test__given_execution__then_returns_status_string(self, mock_httpx_client):
             assert status == MODAL_EXECUTION_STATUS_RUNNING
 
     class TestGetExecutionResult:
-        def test__given_complete_execution__then_returns_result(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_complete_execution__then_returns_result(self):
             # Given
             api = SimulationAPIModal()
             execution = ModalSimulationExecution(
@@ -1272,9 +1276,8 @@ def test__given_complete_execution__then_returns_result(
             # Then
             assert result == MOCK_SIMULATION_RESULT
 
-        def test__given_incomplete_execution__then_returns_none(
-            self, mock_httpx_client
-        ):
+        @pytest.mark.usefixtures("mock_httpx_client")
+        def test__given_incomplete_execution__then_returns_none(self):
             # Given
             api = SimulationAPIModal()
             execution = ModalSimulationExecution(
@@ -1290,9 +1293,8 @@ def test__given_incomplete_execution__then_returns_none(
             assert result is None
 
     class TestHealthCheck:
-        def test__given_healthy_api__then_returns_true(
-            self, mock_httpx_client, mock_modal_logger
-        ):
+        @pytest.mark.usefixtures("mock_modal_logger")
+        def test__given_healthy_api__then_returns_true(self, mock_httpx_client):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=200,
@@ -1306,9 +1308,8 @@ def test__given_healthy_api__then_returns_true(
             # Then
             assert is_healthy is True
 
-        def test__given_unhealthy_api__then_returns_false(
-            self, mock_httpx_client, mock_modal_logger
-        ):
+        @pytest.mark.usefixtures("mock_modal_logger")
+        def test__given_unhealthy_api__then_returns_false(self, mock_httpx_client):
             # Given
             mock_httpx_client.get.return_value = create_mock_httpx_response(
                 status_code=503,
@@ -1322,9 +1323,8 @@ def test__given_unhealthy_api__then_returns_false(
             # Then
             assert is_healthy is False
 
-        def test__given_network_error__then_returns_false(
-            self, mock_httpx_client, mock_modal_logger
-        ):
+        @pytest.mark.usefixtures("mock_modal_logger")
+        def test__given_network_error__then_returns_false(self, mock_httpx_client):
             # Given
             mock_httpx_client.get.side_effect = httpx.RequestError("Connection failed")
             api = SimulationAPIModal()
diff --git a/tests/unit/routes/test_calculate_deprecated_inputs.py b/tests/unit/routes/test_calculate_deprecated_inputs.py
index 4081d30cc..aa25803d0 100644
--- a/tests/unit/routes/test_calculate_deprecated_inputs.py
+++ b/tests/unit/routes/test_calculate_deprecated_inputs.py
@@ -285,7 +285,7 @@ def test__calculate_full__drops_deprecated_input_after_add_missing(monkeypatch):
     )
     monkeypatch.setattr(
         "policyengine_api.services.household_calculation_service.add_yearly_variables",
-        lambda household, country_id, countries=None: {
+        lambda household, _country_id, _countries=None: {
             **household,
             "people": {
                 **household["people"],
diff --git a/tests/unit/routes/test_calculate_error_statuses.py b/tests/unit/routes/test_calculate_error_statuses.py
index a2e9dd23f..c3862296b 100644
--- a/tests/unit/routes/test_calculate_error_statuses.py
+++ b/tests/unit/routes/test_calculate_error_statuses.py
@@ -35,7 +35,7 @@ def calculate(self, household, policy, **_kwargs):
         raise RuntimeError(msg)
 
 
-def make_client(monkeypatch, country, add_missing=False):
+def make_client(monkeypatch, country, *, add_missing=False):
     monkeypatch.setattr(
         household_routes,
         "household_calculation_service",
@@ -47,7 +47,7 @@ def make_client(monkeypatch, country, add_missing=False):
     if add_missing:
         monkeypatch.setattr(
             "policyengine_api.services.household_calculation_service.add_yearly_variables",
-            lambda household, country_id, countries=None: household,
+            lambda household, _country_id, _countries=None: household,
         )
     app.register_blueprint(household_routes.household_bp)
     return app.test_client()
diff --git a/tests/unit/routes/test_canonical_spm.py b/tests/unit/routes/test_canonical_spm.py
index 38605f390..c10ebf22a 100644
--- a/tests/unit/routes/test_canonical_spm.py
+++ b/tests/unit/routes/test_canonical_spm.py
@@ -2,6 +2,7 @@
 
 from copy import deepcopy
 from types import SimpleNamespace
+from typing import ClassVar
 from unittest.mock import patch
 
 import pytest
@@ -40,7 +41,7 @@ def to_dict(self):
 
 
 class Country:
-    metadata = {
+    metadata: ClassVar[dict] = {
         "variables": {
             "age": {"entity": "person", "definitionPeriod": "year", "name": "age"}
         },
@@ -102,7 +103,9 @@ def certified(monkeypatch):
         spm,
         "_selected_forecast",
         lambda _: SimpleNamespace(
-            years=[2022], entry=lambda *a, **k: {}, geography_factor=lambda *a, **k: 1.0
+            years=[2022],
+            entry=lambda *_args, **_kwargs: {},
+            geography_factor=lambda *_args, **_kwargs: 1.0,
         ),
     )
     return bundle
@@ -152,7 +155,8 @@ def harness(monkeypatch, orm_session_factory):
 
 @pytest.mark.parametrize("code", sorted(spm.SPM_INPUT_ERROR_CODES))
 @pytest.mark.parametrize("path", ["/us/calculate", "/us/calculate-full", "stored"])
-def test_spm_input_errors_are_structured_400(certified, harness, code, path):
+@pytest.mark.usefixtures("certified")
+def test_spm_input_errors_are_structured_400(harness, code, path):
     client, country = harness
     country.error_code = code
     if path == "stored":
@@ -190,9 +194,8 @@ def test_spm_input_errors_are_structured_400(certified, harness, code, path):
     ],
 )
 @pytest.mark.parametrize("path", ["/us/calculate", "/us/household"])
-def test_invalid_settings_never_reach_country_or_storage(
-    certified, harness, selection, path
-):
+@pytest.mark.usefixtures("certified")
+def test_invalid_settings_never_reach_country_or_storage(harness, selection, path):
     client, country = harness
     response = client.post(
         path, json={"household": HOUSEHOLD, "data": HOUSEHOLD, "spm": selection}
@@ -202,9 +205,8 @@ def test_invalid_settings_never_reach_country_or_storage(
     assert country.calls == []
 
 
-def test_settings_and_provenance_survive_storage_reform_replay_and_replacement(
-    certified, harness
-):
+@pytest.mark.usefixtures("certified")
+def test_settings_and_provenance_survive_storage_reform_replay_and_replacement(harness):
     client, country = harness
     response = client.post(
         "/us/household", json={"data": HOUSEHOLD, "spm": {"geography_kind": "national"}}
@@ -274,7 +276,8 @@ def test_settings_and_provenance_survive_storage_reform_replay_and_replacement(
         {"as_of": "2026-09-09"},
     ],
 )
-def test_http_cache_varies_with_measurement_settings(certified, harness, selection):
+@pytest.mark.usefixtures("certified")
+def test_http_cache_varies_with_measurement_settings(harness, selection):
     client, country = harness
     payload = {"household": HOUSEHOLD, "spm": {"geography_kind": "national"}}
     first = client.post("/us/calculate", json=payload)
@@ -288,7 +291,8 @@ def test_http_cache_varies_with_measurement_settings(certified, harness, selecti
     assert first.json["spm_provenance"] != second.json["spm_provenance"]
 
 
-def test_successful_http_cache_hit_still_starts_observability(certified, harness):
+@pytest.mark.usefixtures("certified")
+def test_successful_http_cache_hit_still_starts_observability(harness):
     client, country = harness
     payload = {"household": HOUSEHOLD}
 
@@ -340,8 +344,9 @@ def test_http_cache_default_artifact_hash_is_part_of_identity(certified, harness
     assert first.json["spm_provenance"] != second.json["spm_provenance"]
 
 
+@pytest.mark.usefixtures("certified")
 def test_linked_household_measurement_is_immutable_for_saved_reports(
-    certified, harness, orm_session_factory
+    harness, orm_session_factory
 ):
     client, _ = harness
     created = client.post(
@@ -371,8 +376,9 @@ def test_linked_household_measurement_is_immutable_for_saved_reports(
     assert saved["household_json"] == HOUSEHOLD
 
 
+@pytest.mark.usefixtures("certified")
 def test_certification_protects_linked_households_without_saved_spm(
-    certified, harness, orm_session_factory
+    harness, orm_session_factory
 ):
     client, _ = harness
     historical_output = {"result": {"household_net_income": 12345}}
@@ -442,8 +448,9 @@ def test_certification_protects_linked_households_without_saved_spm(
 
 
 @pytest.mark.parametrize("write_source", ["cloud_sql", "dual_write"])
+@pytest.mark.usefixtures("certified")
 def test_household_creation_retains_resolved_spm_before_selected_mirror(
-    certified, harness, orm_session_factory, monkeypatch, write_source
+    harness, orm_session_factory, monkeypatch, write_source
 ):
     from unittest.mock import Mock
 
@@ -494,8 +501,9 @@ def copy_committed_event(country_id, household_id, **_kwargs):
 
 
 @pytest.mark.parametrize("write_source", ["cloud_sql", "dual_write"])
+@pytest.mark.usefixtures("certified")
 def test_invalid_spm_stops_before_database_and_mirror(
-    certified, harness, monkeypatch, write_source
+    harness, monkeypatch, write_source
 ):
     from unittest.mock import Mock
 
@@ -519,8 +527,9 @@ def test_invalid_spm_stops_before_database_and_mirror(
 
 
 @pytest.mark.parametrize("write_source", ["cloud_sql", "dual_write"])
+@pytest.mark.usefixtures("certified")
 def test_valid_spm_database_timeout_keeps_stage11_safe_persistence_response(
-    certified, harness, monkeypatch, write_source
+    harness, monkeypatch, write_source
 ):
     from unittest.mock import Mock
 
@@ -548,7 +557,8 @@ def test_valid_spm_database_timeout_keeps_stage11_safe_persistence_response(
     copy_event.assert_not_called()
 
 
-def test_stored_replay_rejects_a_receipt_that_omits_null_settings(certified, harness):
+@pytest.mark.usefixtures("certified")
+def test_stored_replay_rejects_a_receipt_that_omits_null_settings(harness):
     """The sole receipt must state every field in its resolved configuration."""
     client, country = harness
     calculate = country.calculate
@@ -640,8 +650,9 @@ def test_canonical_model_without_certification_refuses_every_us_surface(
 
 
 @pytest.mark.parametrize("code", sorted(spm.SPM_INPUT_ERROR_CODES))
+@pytest.mark.usefixtures("certified")
 def test_household_saved_without_a_selection_replays_with_null_spm_variables(
-    certified, harness, orm_session_factory, code
+    harness, orm_session_factory, code
 ):
     """A household that never chose a measurement keeps replaying under any policy.
 
@@ -674,9 +685,8 @@ def test_household_saved_without_a_selection_replays_with_null_spm_variables(
 
 
 @pytest.mark.parametrize("code", sorted(spm.SPM_INPUT_ERROR_CODES))
-def test_household_saved_with_a_selection_still_fails_closed_on_replay(
-    certified, harness, code
-):
+@pytest.mark.usefixtures("certified")
+def test_household_saved_with_a_selection_still_fails_closed_on_replay(harness, code):
     client, country = harness
     created = client.post(
         "/us/household", json={"data": HOUSEHOLD, "spm": {"geography_kind": "national"}}
@@ -691,8 +701,9 @@ def test_household_saved_with_a_selection_still_fails_closed_on_replay(
 
 @pytest.mark.parametrize("code", sorted(spm.SPM_INPUT_ERROR_CODES))
 @pytest.mark.parametrize("path", ["/us/calculate", "/us/calculate-full"])
+@pytest.mark.usefixtures("certified")
 def test_calculation_without_a_chosen_measurement_returns_null_spm_variables(
-    certified, harness, code, path
+    harness, code, path
 ):
     """An omitted selection inherits defaults but does not assert a choice."""
     client, country = harness
@@ -709,15 +720,16 @@ def test_calculation_without_a_chosen_measurement_returns_null_spm_variables(
     assert country.calls[0][2]["spm"]["geography_kind"] == "county"
 
 
+@pytest.mark.usefixtures("certified")
 def test_certification_does_not_change_what_an_unselected_household_stores(
-    certified, harness, orm_session_factory
+    harness, orm_session_factory
 ):
     """Identical inputs keep their hash, stored JSON and GET shape.
 
     Writing back the defaults a caller never chose would move every household
     hash the day a bundle is certified, and record a choice nobody made.
     """
-    client, country = harness
+    client, _country = harness
     created = client.post("/us/household", json={"data": HOUSEHOLD})
     assert created.status_code == 201, created.json
     household_id = created.json["result"]["household_id"]
@@ -731,8 +743,9 @@ def test_certification_does_not_change_what_an_unselected_household_stores(
 
 
 @pytest.mark.parametrize("code", sorted(spm.SPM_INPUT_ERROR_CODES))
+@pytest.mark.usefixtures("certified")
 def test_a_household_created_without_a_selection_replays_rather_than_failing(
-    certified, harness, code
+    harness, code
 ):
     """The write-time rule and the replay-time rule have to agree.
 
@@ -756,15 +769,16 @@ def test_a_household_created_without_a_selection_replays_rather_than_failing(
 
 
 @pytest.mark.parametrize(
-    "path,body",
+    ("path", "body"),
     [
         ("/us/calculate", {"household": HOUSEHOLD, "spm": None}),
         ("/us/calculate-full", {"household": HOUSEHOLD, "spm": None}),
         ("/us/household", {"data": HOUSEHOLD, "spm": None}),
     ],
 )
+@pytest.mark.usefixtures("certified")
 def test_an_explicit_null_selection_is_rejected_rather_than_read_as_omission(
-    certified, harness, path, body
+    harness, path, body
 ):
     """v2 documents and simulation records refuse a null; v1 must not differ."""
     client, country = harness
@@ -810,7 +824,8 @@ def test_a_saved_selection_this_deployment_cannot_serve_is_not_a_caller_error(
     assert requested.json["errors"][0]["code"] == "SPM_SETTINGS_INVALID"
 
 
-def test_a_rejected_selection_never_quotes_validator_internals(certified, harness):
+@pytest.mark.usefixtures("certified")
+def test_a_rejected_selection_never_quotes_validator_internals(harness):
     """The message a client shows its users is ours, not pydantic's."""
     client, _ = harness
     response = client.post(
@@ -826,7 +841,7 @@ def test_a_rejected_selection_never_quotes_validator_internals(certified, harnes
 
 
 @pytest.mark.parametrize(
-    "path,body",
+    ("path", "body"),
     [
         ("/uk/calculate", {"household": HOUSEHOLD, "spm": None}),
         ("/uk/calculate-full", {"household": HOUSEHOLD, "spm": None}),
@@ -837,8 +852,9 @@ def test_a_rejected_selection_never_quotes_validator_internals(certified, harnes
         ),
     ],
 )
+@pytest.mark.usefixtures("certified")
 def test_a_country_without_spm_reports_the_field_itself_as_unsupported(
-    certified, harness, path, body
+    harness, path, body
 ):
     """A null there is not a shape to correct; the field does not exist for UK.
 
diff --git a/tests/unit/routes/test_economy_failure_replay.py b/tests/unit/routes/test_economy_failure_replay.py
index 13ce48997..8ade23ff4 100644
--- a/tests/unit/routes/test_economy_failure_replay.py
+++ b/tests/unit/routes/test_economy_failure_replay.py
@@ -39,10 +39,13 @@ def failed_job_harness(request, monkeypatch):
         "contract_version": "canonical-spm-v1",
         "defaults": SELECTION,
     }
-    gateway.resolve_app_name.side_effect = lambda country_id, version=None, **kwargs: (
-        "test-worker",
-        version,
-    )
+
+    def resolve_app_name(
+        _country_id: str, version: str | None = None, **_kwargs: object
+    ) -> tuple[str, str | None]:
+        return "test-worker", version
+
+    gateway.resolve_app_name.side_effect = resolve_app_name
     gateway.get_execution_by_id.return_value = SimpleNamespace(error=WORKER_ERROR)
     gateway.get_execution_status.return_value = "failed"
     cache = ReformImpactCache(
diff --git a/tests/unit/routes/test_economy_spm_query.py b/tests/unit/routes/test_economy_spm_query.py
index a65f39e06..b2abba047 100644
--- a/tests/unit/routes/test_economy_spm_query.py
+++ b/tests/unit/routes/test_economy_spm_query.py
@@ -27,7 +27,7 @@ def economy_http(request, monkeypatch):
     monkeypatch.setattr(
         spm,
         "_selected_forecast",
-        lambda _: SimpleNamespace(years=[2026], entry=lambda *args, **kwargs: {}),
+        lambda _: SimpleNamespace(years=[2026], entry=lambda *_args, **_kwargs: {}),
     )
     gateway = Mock()
     gateway.get_spm_capability.return_value = {
@@ -80,7 +80,7 @@ def calculate(**kwargs):
 def test_json_spm_selection_reaches_real_worker_validation(economy_http):
     client, path, query, dispatch, gateway, setups = economy_http
     response = client.get(
-        path, query_string=query + [("spm", json.dumps({"geography_kind": "national"}))]
+        path, query_string=[*query, ("spm", json.dumps({"geography_kind": "national"}))]
     )
     assert response.status_code == 200, response.get_json()
     assert response.get_json()["status"] == "computing"
@@ -108,7 +108,7 @@ def test_json_spm_selection_reaches_real_worker_validation(economy_http):
 )
 def test_malformed_spm_query_never_dispatches(economy_http, value):
     client, path, query, dispatch, gateway, _ = economy_http
-    response = client.get(path, query_string=query + [("spm", value)])
+    response = client.get(path, query_string=[*query, ("spm", value)])
     assert response.status_code == 400
     assert response.get_json()["errors"][0]["code"] == "SPM_SETTINGS_INVALID"
     dispatch.assert_not_called()
@@ -119,7 +119,7 @@ def test_malformed_spm_query_never_dispatches(economy_http, value):
 def test_duplicate_scalar_economy_queries_never_dispatch(economy_http, field):
     client, path, query, dispatch, gateway, _ = economy_http
     query = [(key, value) for key, value in query if key != field]
-    response = client.get(path, query_string=query + [(field, "{}"), (field, "{}")])
+    response = client.get(path, query_string=[*query, (field, "{}"), (field, "{}")])
     assert response.status_code == 400
     assert "must not be repeated" in response.get_json()["message"]
     dispatch.assert_not_called()
@@ -137,7 +137,7 @@ def test_duplicate_scalar_economy_queries_never_dispatch(economy_http, field):
 )
 def test_undeclared_economy_query_never_dispatches(economy_http, extra):
     client, path, query, dispatch, gateway, setups = economy_http
-    response = client.get(path, query_string=query + [extra])
+    response = client.get(path, query_string=[*query, extra])
     assert response.status_code == 400
     assert extra[0] in response.get_json()["message"]
     dispatch.assert_not_called()
@@ -147,7 +147,7 @@ def test_undeclared_economy_query_never_dispatches(economy_http, extra):
 
 def test_dataset_query_is_rejected_before_dispatch(economy_http):
     client, path, query, dispatch, gateway, setups = economy_http
-    response = client.get(path, query_string=query + [("dataset", "other")])
+    response = client.get(path, query_string=[*query, ("dataset", "other")])
 
     assert response.status_code == 400
     assert "dataset" in response.get_json()["message"]
@@ -193,7 +193,7 @@ def test_invalid_numeric_query_values_never_dispatch(economy_http, value):
     client, path, query, dispatch, _, _ = economy_http
     field = "window_size" if path.endswith("/budget-window") else "time_period"
     query = [(key, item) for key, item in query if key != field]
-    response = client.get(path, query_string=query + [(field, value)])
+    response = client.get(path, query_string=[*query, (field, value)])
     assert response.status_code == 400
     dispatch.assert_not_called()
 
@@ -203,7 +203,7 @@ def test_malformed_economy_years_never_dispatch(economy_http, value):
     client, path, query, dispatch, _, _ = economy_http
     field = "start_year" if path.endswith("/budget-window") else "time_period"
     query = [(key, item) for key, item in query if key != field]
-    response = client.get(path, query_string=query + [(field, value)])
+    response = client.get(path, query_string=[*query, (field, value)])
     assert response.status_code == 400
     dispatch.assert_not_called()
 
@@ -232,7 +232,7 @@ def test_bundle_version_bump_without_measurements_still_dispatches(
 def test_canonical_model_without_certification_refuses_economy_requests(
     economy_http, monkeypatch
 ):
-    client, path, query, dispatch, gateway, _ = economy_http
+    client, path, query, _dispatch, gateway, _ = economy_http
     monkeypatch.setattr(
         spm,
         "_current_bundle",
@@ -269,7 +269,7 @@ def test_a_rejected_economy_selection_quotes_no_validator_internals(
     name the offending field and reason and nothing else.
     """
     client, path, query, dispatch, _, _ = economy_http
-    response = client.get(path, query_string=query + [("spm", json.dumps(selection))])
+    response = client.get(path, query_string=[*query, ("spm", json.dumps(selection))])
     assert response.status_code == 400, response.get_json()
     error = response.get_json()["errors"][0]
     assert error["code"] == "SPM_SETTINGS_INVALID"
diff --git a/tests/unit/routes/test_household_numeric_identity.py b/tests/unit/routes/test_household_numeric_identity.py
index 604c5f710..8186e1583 100644
--- a/tests/unit/routes/test_household_numeric_identity.py
+++ b/tests/unit/routes/test_household_numeric_identity.py
@@ -92,7 +92,7 @@ def test_opaque_simulation_identity_stays_distinct_for_immutable_household(
     assert control.status_code == 405
 
     if spelling in {"arabic", "fullwidth"}:
-        digits = "٠١٢٣٤٥٦٧٨٩" if spelling == "arabic" else "０１２３４５６７８９"
+        digits = "٠١٢٣٤٥٦٧٨٩" if spelling == "arabic" else "０１２３４５６７８９"  # noqa: RUF001  # non-ASCII digits are the input under test
         population_id = str(household_id).translate(str.maketrans("0123456789", digits))
     else:
         population_id = spelling.format(id=household_id)
diff --git a/tests/unit/routes/test_metadata_routes_streaming.py b/tests/unit/routes/test_metadata_routes_streaming.py
index 667d46f3c..519c374fc 100644
--- a/tests/unit/routes/test_metadata_routes_streaming.py
+++ b/tests/unit/routes/test_metadata_routes_streaming.py
@@ -7,6 +7,7 @@
 import json
 import sys
 from types import SimpleNamespace
+from typing import ClassVar
 
 import pytest
 from flask import Flask
@@ -18,7 +19,7 @@
 
 
 class _MetadataService:
-    metadata_by_country: dict = {}
+    metadata_by_country: ClassVar[dict] = {}
 
     def get_metadata(self, country_id: str):
         return self.metadata_by_country[country_id]
diff --git a/tests/unit/routes/test_policy_dual_write_routes.py b/tests/unit/routes/test_policy_dual_write_routes.py
index 4dfd49cca..24a8940b3 100644
--- a/tests/unit/routes/test_policy_dual_write_routes.py
+++ b/tests/unit/routes/test_policy_dual_write_routes.py
@@ -83,7 +83,7 @@ def test_cloud_sql_mode_preserves_v1_create_response_without_mirroring(
     mirror.assert_not_called()
 
 
-@pytest.mark.parametrize("country_id", ("us", "uk"))
+@pytest.mark.parametrize("country_id", ["us", "uk"])
 def test_dual_write_mirrors_new_and_existing_rows_before_success(
     monkeypatch,
     country_id,
@@ -92,12 +92,14 @@ def test_dual_write_mirrors_new_and_existing_rows_before_success(
     for existing, expected_status in ((False, 201), (True, 200)):
         events: list[str] = []
         service = MagicMock(
-            side_effect=lambda *_args, **_kwargs: (
+            side_effect=lambda *_args, events=events, existing=existing, **_kwargs: (
                 events.append("cloud_sql")
                 or _creation(existing=existing, country_id=country_id)
             )
         )
-        mirror = MagicMock(side_effect=lambda _snapshot: events.append("supabase"))
+        mirror = MagicMock(
+            side_effect=lambda _snapshot, events=events: events.append("supabase")
+        )
         with (
             patch(
                 "policyengine_api.routes.policy_routes.policy_service.set_policy",
@@ -118,7 +120,7 @@ def test_dual_write_mirrors_new_and_existing_rows_before_success(
         mirror.assert_called_once_with(_snapshot(country_id))
 
 
-@pytest.mark.parametrize("country_id", ("ca", "ng", "il"))
+@pytest.mark.parametrize("country_id", ["ca", "ng", "il"])
 def test_dual_write_preserves_v1_only_policy_writes_for_non_v2_countries(
     monkeypatch,
     country_id,
diff --git a/tests/unit/routes/test_report_household_identity.py b/tests/unit/routes/test_report_household_identity.py
index 4361e3bbd..c1a63c5c2 100644
--- a/tests/unit/routes/test_report_household_identity.py
+++ b/tests/unit/routes/test_report_household_identity.py
@@ -162,7 +162,8 @@ def comparison_models(country_id, population_type, first_id, second_id):
 
 
 @pytest.mark.parametrize(
-    "unrelated_id", ["1suffix", "1.0", "+1", "1\n", "١", "１", "2"]
+    "unrelated_id",
+    ["1suffix", "1.0", "+1", "1\n", "١", "１", "2"],  # noqa: RUF001  # non-ASCII digits are the input under test
 )
 def test_household_report_does_not_alias_nonnumeric_or_different_ids(unrelated_id):
     models = comparison_models("us", "household", "00001", unrelated_id)
@@ -171,7 +172,7 @@ def test_household_report_does_not_alias_nonnumeric_or_different_ids(unrelated_i
 
 
 @pytest.mark.parametrize(
-    "country_id,population_type",
+    ("country_id", "population_type"),
     [("uk", "household"), ("us", "geography"), ("uk", "geography")],
 )
 def test_numeric_report_aliases_are_limited_to_us_households(
@@ -183,7 +184,8 @@ def test_numeric_report_aliases_are_limited_to_us_households(
 
 
 @pytest.mark.parametrize(
-    "population_id", ["household-1", "1suffix", "1.0", "+1", "1\n", "١", "１"]
+    "population_id",
+    ["household-1", "1suffix", "1.0", "+1", "1\n", "١", "１"],  # noqa: RUF001  # non-ASCII digits are the input under test
 )
 def test_matching_literal_household_ids_retain_saved_spelling(population_id):
     models = comparison_models("us", "household", population_id, population_id)
diff --git a/tests/unit/routes/test_user_policy_dual_write_routes.py b/tests/unit/routes/test_user_policy_dual_write_routes.py
index 87c323325..d0c6e9d01 100644
--- a/tests/unit/routes/test_user_policy_dual_write_routes.py
+++ b/tests/unit/routes/test_user_policy_dual_write_routes.py
@@ -160,7 +160,7 @@ def test_cloud_sql_mode_preserves_create_without_association_mirror(
     get_reform.assert_not_called()
 
 
-@pytest.mark.parametrize("country_id", ("us", "uk"))
+@pytest.mark.parametrize("country_id", ["us", "uk"])
 def test_dual_write_mirrors_new_existing_and_unlabeled_saved_policies(
     monkeypatch,
     country_id,
@@ -203,7 +203,7 @@ def test_dual_write_mirrors_new_existing_and_unlabeled_saved_policies(
         assert mirror.call_args.kwargs["through_revision"] == 1
 
 
-@pytest.mark.parametrize("country_id", ("ca", "ng", "il"))
+@pytest.mark.parametrize("country_id", ["ca", "ng", "il"])
 def test_dual_write_preserves_v1_only_saved_policy_mutations_for_non_v2_countries(
     monkeypatch,
     country_id,
@@ -314,7 +314,7 @@ def test_saved_policy_mirror_failure_returns_503_and_retry_completes(
         "expected_category",
         "expected_operation",
     ),
-    (
+    [
         (
             "post",
             "create_or_get_user_policy",
@@ -377,7 +377,7 @@ def test_saved_policy_mirror_failure_returns_503_and_retry_completes(
             "unexpected",
             "update",
         ),
-    ),
+    ],
 )
 def test_saved_policy_persistence_failures_use_allowlisted_records(
     monkeypatch,
diff --git a/tests/unit/runtime_cache/test_reform_impacts.py b/tests/unit/runtime_cache/test_reform_impacts.py
index 2f47afc6f..faea70023 100644
--- a/tests/unit/runtime_cache/test_reform_impacts.py
+++ b/tests/unit/runtime_cache/test_reform_impacts.py
@@ -295,7 +295,7 @@ def test_terminal_error_clears_worker_handle_without_changing_cache_identity(
 def test_failed_terminal_error_write_keeps_existing_worker_handle(monkeypatch):
     cache = ReformImpactCache(InMemoryCacheBackend(), _namespace())
     cache.set(_impact("job", "selection", 1))
-    monkeypatch.setattr(cache, "set", lambda *args, **kwargs: False)
+    monkeypatch.setattr(cache, "set", lambda *_args, **_kwargs: False)
 
     assert cache.update("job", status="error", clear_execution_id=True) is None
     unchanged = cache.get_by_execution_id("job")
diff --git a/tests/unit/services/test_budget_window_cache.py b/tests/unit/services/test_budget_window_cache.py
index b18fd22bb..eff158f05 100644
--- a/tests/unit/services/test_budget_window_cache.py
+++ b/tests/unit/services/test_budget_window_cache.py
@@ -33,7 +33,7 @@ def get(self, key):
             raise RuntimeError(msg)
         return
 
-    def set(self, key, value, nx=False, ex=None):
+    def set(self, key, value, *, nx=False, ex=None):
         if self.method == "set":
             msg = "redis unavailable"
             raise RuntimeError(msg)
diff --git a/tests/unit/services/test_direct_orm_policy_household.py b/tests/unit/services/test_direct_orm_policy_household.py
index be805d5aa..31ed1de52 100644
--- a/tests/unit/services/test_direct_orm_policy_household.py
+++ b/tests/unit/services/test_direct_orm_policy_household.py
@@ -11,7 +11,7 @@ def test_policy_service_reads_and_writes_mapped_models(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: "policy-hash",
+        lambda _value: "policy-hash",
     )
     service = PolicyService(orm_session_factory)
 
@@ -34,7 +34,7 @@ def test_household_service_reads_and_writes_mapped_models(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "household-hash",
+        lambda _value: "household-hash",
     )
     service = HouseholdService(orm_session_factory)
     payload = {"people": {"you": {"age": {"2026": 40}}}}
diff --git a/tests/unit/services/test_economy_service.py b/tests/unit/services/test_economy_service.py
index 9a80cfeda..943a76d5d 100644
--- a/tests/unit/services/test_economy_service.py
+++ b/tests/unit/services/test_economy_service.py
@@ -166,18 +166,20 @@ def base_params(self):
                 "target": "general",
             }
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_completed_impact__returns_completed_result(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(status="ok")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -200,18 +202,20 @@ def test__given_completed_impact__returns_completed_result(
             (hash_prefix_lookup(mock_reform_impacts_service).assert_called_once())
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_orm_decoded_completed_impact__returns_completed_result(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(status="ok")
             completed_impact.reform_impact_json = json.loads(
@@ -240,20 +244,22 @@ def test__given_orm_decoded_completed_impact__returns_completed_result(
                 (None, "Simulation entrypoint execution failed"),
             ],
         )
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_cached_error_impact__returns_error_message(
             self,
             cached_message,
             expected_message,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             failed_impact = create_mock_reform_impact(
                 status="error",
@@ -271,18 +277,20 @@ def test__given_cached_error_impact__returns_error_message(
             mock_simulation_entrypoint.run.assert_not_called()
             mock_simulation_entrypoint.get_execution_by_id.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_legacy_completed_impact__refreshes_cache(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(
                 status="ok",
@@ -303,18 +311,20 @@ def test__given_legacy_completed_impact__refreshes_cache(
             )
             mock_simulation_entrypoint.run.assert_called_once()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_computing_impact_with_succeeded_execution__returns_completed(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             computing_impact = create_mock_reform_impact(status="computing")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -342,18 +352,20 @@ def test__given_computing_impact_with_succeeded_execution__returns_completed(
             )
             mock_reform_impacts_service.set_complete_reform_impact.assert_called_once()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_computing_impact_with_failed_execution__returns_error_result(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             computing_impact = create_mock_reform_impact(status="computing")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -374,18 +386,20 @@ def test__given_computing_impact_with_failed_execution__returns_error_result(
             )
             mock_reform_impacts_service.set_error_reform_impact.assert_called_once()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_computing_impact_with_active_execution__returns_computing(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             computing_impact = create_mock_reform_impact(status="computing")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -398,18 +412,20 @@ def test__given_computing_impact_with_active_execution__returns_computing(
             assert result.status == ImpactStatus.COMPUTING
             assert result.data is None
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_no_previous_impact__creates_new_simulation(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
 
@@ -436,18 +452,20 @@ def test__given_no_previous_impact__creates_new_simulation(
             assert write_values["reform_impact_json"] == {}
             assert write_values["observability_id"] == MOCK_OBSERVABILITY_ID
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_no_previous_impact__starts_observability_after_claim(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
             lifecycle_events = []
@@ -467,18 +485,20 @@ def test__given_no_previous_impact__starts_observability_after_claim(
             start_observability_id.assert_called_once_with(MOCK_OBSERVABILITY_ID)
             assert lifecycle_events == ["claim", "start"]
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__selected_observability_id_is_applied_to_containing_spans(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
 
@@ -495,18 +515,20 @@ def test__selected_observability_id_is_applied_to_containing_spans(
                 == 2
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_existing_start_claim__does_not_submit_duplicate_simulation(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.claim_reform_impact_start.return_value = False
             winning_observability_id = "00000000-0000-4000-8000-000000000003"
@@ -529,18 +551,20 @@ def test__given_existing_start_claim__does_not_submit_duplicate_simulation(
             mock_reform_impacts_service.set_reform_impact.assert_not_called()
             mock_reform_impacts_service.release_reform_impact_start.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_expired_contended_claim__retries_and_submits(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.claim_reform_impact_start.side_effect = [
                 False,
@@ -562,18 +586,20 @@ def test__given_expired_contended_claim__retries_and_submits(
             start_observability_id.assert_called_once_with(MOCK_OBSERVABILITY_ID)
             mock_simulation_entrypoint.run.assert_called_once()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_repeatedly_expiring_start_claims__fails_before_submission(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.claim_reform_impact_start.return_value = False
             mock_reform_impacts_service.get_reform_impact_start_claim.return_value = (
@@ -602,18 +628,20 @@ def test__given_repeatedly_expiring_start_claims__fails_before_submission(
             start_observability_id.assert_not_called()
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_start_claim_cache_failure__fails_before_submission(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.claim_reform_impact_start.side_effect = (
                 CacheCoordinationError("cache unavailable")
@@ -625,18 +653,20 @@ def test__given_start_claim_cache_failure__fails_before_submission(
             mock_simulation_entrypoint.run.assert_not_called()
             mock_reform_impacts_service.set_reform_impact.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_gateway_raises_before_returning_execution__releases_start_claim(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_simulation_entrypoint.run.side_effect = RuntimeError(
                 "submission failed"
@@ -649,18 +679,20 @@ def test__given_gateway_raises_before_returning_execution__releases_start_claim(
                 **mock_reform_impacts_service.claim_reform_impact_start.call_args.kwargs
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_submitted_simulation_handoff_failure__retains_start_claim(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.set_reform_impact.side_effect = (
                 ReformImpactHandoffError("cache unavailable")
@@ -672,18 +704,20 @@ def test__given_submitted_simulation_handoff_failure__retains_start_claim(
             mock_simulation_entrypoint.run.assert_called_once()
             mock_reform_impacts_service.release_reform_impact_start.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_submitted_simulation_without_execution_id__retains_start_claim(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_simulation_entrypoint.get_execution_id.side_effect = RuntimeError(
                 "missing execution identifier"
@@ -753,18 +787,20 @@ def test__given_policies_created_through_orm__submits_decoded_json(
             assert submitted["baseline"] == {}
             assert submitted["reform"] == reform
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_no_previous_impact__includes_metadata_in_simulation_params(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             """Verify that _metadata with policy IDs is passed to simulation API."""
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
@@ -798,17 +834,19 @@ def test__given_no_previous_impact__includes_metadata_in_simulation_params(
                 sim_params["_metadata"]["resolved_app_name"] == MOCK_RESOLVED_APP_NAME
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policy_service",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_no_previous_impact__includes_telemetry_in_simulation_params(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
             mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_reform_impacts_service.get_all_reform_impacts.return_value = []
 
@@ -832,24 +870,26 @@ def test__given_no_previous_impact__includes_telemetry_in_simulation_params(
                 mock_logger.log_struct.call_args_list[-1].kwargs["severity"] == "INFO"
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_runtime_cache_version__uses_versioned_economy_cache_key(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
             monkeypatch,
         ):
             cache_version = "e1cache01"
             monkeypatch.setattr(
                 "policyengine_api.services.economy_service.get_economy_impact_cache_version",
-                lambda country_id, api_version=None: cache_version,
+                lambda _country_id, _api_version=None: cache_version,
             )
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
 
@@ -869,18 +909,20 @@ def test__given_runtime_cache_version__uses_versioned_economy_cache_key(
                 cache_version,
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_default_dataset__queries_previous_impacts_with_resolved_bundle(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
 
@@ -896,18 +938,20 @@ def test__given_default_dataset__queries_previous_impacts_with_resolved_bundle(
             assert "policyengine\\_version=3.4.0" in call_args[7]
             assert "runtime_app_name" not in call_args[7]
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_completed_impact__uses_resolved_runtime_bundle_for_cache_lookup(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(status="ok")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -923,18 +967,20 @@ def test__given_completed_impact__uses_resolved_runtime_bundle_for_cache_lookup(
                 policyengine_version=MOCK_POLICYENGINE_VERSION,
             )
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_existing_impact__restores_stored_observability_id(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(status="ok")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -956,18 +1002,20 @@ def test__given_existing_impact__restores_stored_observability_id(
             restore_observability_id.assert_called_once_with(MOCK_OBSERVABILITY_ID)
             start_observability_id.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_cached_impact_and_runtime_lookup_fails__returns_cached_result(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(status="ok")
             hash_prefix_lookup(mock_reform_impacts_service).return_value = [
@@ -985,18 +1033,20 @@ def test__given_cached_impact_and_runtime_lookup_fails__returns_cached_result(
             )
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_legacy_cached_impact_without_resolved_app_name__refreshes_cache(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(
                 status="ok",
@@ -1017,18 +1067,20 @@ def test__given_legacy_cached_impact_without_resolved_app_name__refreshes_cache(
             )
             mock_simulation_entrypoint.run.assert_called_once()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_legacy_and_refreshed_cached_impacts__reuses_refreshed_entry(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             legacy_impact = create_mock_reform_impact(
                 status="ok",
@@ -1053,18 +1105,20 @@ def test__given_legacy_and_refreshed_cached_impacts__reuses_refreshed_entry(
             assert hash_prefix_lookup(mock_reform_impacts_service).call_count == 2
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_legacy_cached_impact_and_lookup_fails__returns_cached_result(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             completed_impact = create_mock_reform_impact(
                 status="ok",
@@ -1084,18 +1138,20 @@ def test__given_legacy_cached_impact_and_lookup_fails__returns_cached_result(
             assert result.data["policyengine_bundle"]["model_version"] is None
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_legacy_computing_impact_without_app_name__then_reuses_execution(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             computing_impact = create_mock_reform_impact(
                 status="computing",
@@ -1112,38 +1168,42 @@ def test__given_legacy_computing_impact_without_app_name__then_reuses_execution(
             mock_simulation_entrypoint.resolve_app_name.assert_not_called()
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_exception__raises_error(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
-            mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             hash_prefix_lookup(mock_reform_impacts_service).side_effect = Exception(
                 "Database error"
             )
 
-            with pytest.raises(Exception) as exc_info:
+            with pytest.raises(Exception, match="Database error") as exc_info:
                 economy_service.get_economic_impact(**base_params)
             assert str(exc_info.value) == "Database error"
 
+        @pytest.mark.usefixtures(
+            "mock_policyengine_version",
+            "mock_policy_service",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_uk_request__preserves_model_version_in_bundle(
             self,
             economy_service,
             mock_country_package_versions,
-            mock_policyengine_version,
-            mock_policy_service,
             mock_reform_impacts_service,
             mock_simulation_entrypoint,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
         ):
             mock_country_package_versions["uk"] = "2.7.8"
             hash_prefix_lookup(mock_reform_impacts_service).return_value = []
@@ -1800,23 +1860,25 @@ def test__given_end_year_after_2099__raises_value_error(
             ):
                 economy_service.get_budget_window_economic_impact(**base_params)
 
+        @pytest.mark.usefixtures(
+            "mock_country_package_versions",
+            "mock_simulation_entrypoint",
+            "mock_logger",
+            "mock_datetime",
+            "mock_submission_claim_id",
+        )
         def test__given_runtime_cache_version__uses_versioned_budget_window_cache_key(
             self,
             economy_service,
             base_params,
-            mock_country_package_versions,
-            mock_simulation_entrypoint,
             mock_budget_window_cache,
-            mock_logger,
-            mock_datetime,
-            mock_submission_claim_id,
             monkeypatch,
         ):
             cache_version = "e1cache01"
 
             monkeypatch.setattr(
                 "policyengine_api.services.economy_service.get_economy_impact_cache_version",
-                lambda country_id, api_version=None: cache_version,
+                lambda _country_id, _api_version=None: cache_version,
             )
             result = economy_service.get_budget_window_economic_impact(**base_params)
 
@@ -1862,12 +1924,13 @@ def test__given_reordered_options__uses_same_budget_window_cache_identity(
             assert first_cache_key_kwargs == second_cache_key_kwargs
             mock_simulation_entrypoint.run_budget_window_batch.assert_not_called()
 
+        @pytest.mark.usefixtures(
+            "mock_reform_impacts_service", "mock_simulation_entrypoint"
+        )
         def test__given_legacy_us_region__normalizes_before_building_cache_key(
             self,
             economy_service,
             base_params,
-            mock_reform_impacts_service,
-            mock_simulation_entrypoint,
             mock_budget_window_cache,
         ):
             base_params["region"] = "ca"
@@ -2067,9 +2130,8 @@ def test__given_computing_status__returns_computing(self, economy_service):
         def test__given_unknown_status__raises_error(self, economy_service):
             impact = create_mock_reform_impact(status="unknown")
 
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Unknown impact status: unknown"):
                 economy_service._determine_impact_action(impact)
-            assert "Unknown impact status: unknown" in str(exc_info.value)
 
     class TestHandleExecutionState:
         @pytest.fixture
@@ -2114,13 +2176,13 @@ def test_untyped_poll_error_does_not_persist_a_terminal_failure(
             mock_reform_impacts_service.set_error_reform_impact.assert_not_called()
             mock_simulation_entrypoint.run.assert_not_called()
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_succeeded_state__returns_completed_result(
             self,
             economy_service,
             setup_options,
             mock_simulation_entrypoint,
             mock_reform_impacts_service,
-            mock_logger,
         ):
             reform_impact = create_mock_reform_impact(status="computing")
             mock_execution = MagicMock()
@@ -2149,12 +2211,12 @@ def test__given_succeeded_state__returns_completed_result(
                 == (MOCK_REFORM_IMPACT_DATA["poverty_impact"])
             )
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_failed_state__returns_error_result(
             self,
             economy_service,
             setup_options,
             mock_reform_impacts_service,
-            mock_logger,
         ):
             reform_impact = create_mock_reform_impact(status="computing")
 
@@ -2167,8 +2229,9 @@ def test__given_failed_state__returns_error_result(
             assert result.message == "Simulation entrypoint execution failed"
             mock_reform_impacts_service.set_error_reform_impact.assert_called_once()
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_active_state__returns_computing_result(
-            self, economy_service, setup_options, mock_logger
+            self, economy_service, setup_options
         ):
             reform_impact = create_mock_reform_impact(status="computing")
 
@@ -2184,20 +2247,21 @@ def test__given_unknown_state__raises_error(
         ):
             reform_impact = create_mock_reform_impact(status="computing")
 
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(
+                ValueError, match="Unexpected sim API execution state: UNKNOWN"
+            ):
                 economy_service._handle_execution_state(
                     setup_options, "UNKNOWN", reform_impact
                 )
-            assert "Unexpected sim API execution state: UNKNOWN" in str(exc_info.value)
 
         # Modal status tests
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_complete_state__then_returns_completed_result(
             self,
             economy_service,
             setup_options,
             mock_simulation_entrypoint,
             mock_reform_impacts_service,
-            mock_logger,
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2221,12 +2285,12 @@ def test__given_modal_complete_state__then_returns_completed_result(
             }
             mock_reform_impacts_service.set_complete_reform_impact.assert_called_once()
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_failed_state__then_returns_error_result(
             self,
             economy_service,
             setup_options,
             mock_reform_impacts_service,
-            mock_logger,
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2243,12 +2307,12 @@ def test__given_modal_failed_state__then_returns_error_result(
             assert result.data is None
             mock_reform_impacts_service.set_error_reform_impact.assert_called_once()
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_failure_with_error_message__includes_error_in_message(
             self,
             economy_service,
             setup_options,
             mock_reform_impacts_service,
-            mock_logger,
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2266,8 +2330,9 @@ def test__given_modal_failure_with_error_message__includes_error_in_message(
             call_args = mock_reform_impacts_service.set_error_reform_impact.call_args
             assert "Simulation timed out" in call_args[1]["message"]
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_running_state__then_returns_computing_result(
-            self, economy_service, setup_options, mock_logger
+            self, economy_service, setup_options
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2281,8 +2346,9 @@ def test__given_modal_running_state__then_returns_computing_result(
             assert result.status == ImpactStatus.COMPUTING
             assert result.data is None
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_running_state_with_run_progress__then_relays_it(
-            self, economy_service, setup_options, mock_logger
+            self, economy_service, setup_options
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2308,8 +2374,9 @@ def test__given_modal_running_state_with_run_progress__then_relays_it(
             }
             assert "run_progress" not in result.to_dict()
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_running_state_without_run_progress__then_has_none(
-            self, economy_service, setup_options, mock_logger
+            self, economy_service, setup_options
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2324,8 +2391,9 @@ def test__given_modal_running_state_without_run_progress__then_has_none(
             assert result.status == ImpactStatus.COMPUTING
             assert result.run_progress is None
 
+        @pytest.mark.usefixtures("mock_logger")
         def test__given_modal_submitted_state__then_returns_computing_result(
-            self, economy_service, setup_options, mock_logger
+            self, economy_service, setup_options
         ):
             # Given
             reform_impact = create_mock_reform_impact(status="computing")
@@ -2658,30 +2726,30 @@ def test__given_lowercase_congressional_district__returns_unchanged(
 
         def test__given_invalid_prefixed_state__raises_value_error(self):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid US state: 'mb'"):
                 service._setup_region("us", "state/mb")
-            assert "Invalid US state: 'mb'" in str(exc_info.value)
 
         def test__given_invalid_congressional_district__raises_value_error(
             self,
         ):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(
+                ValueError, match="Invalid congressional district: 'cruft'"
+            ):
                 service._setup_region("us", "congressional_district/cruft")
-            assert "Invalid congressional district: 'cruft'" in str(exc_info.value)
 
         def test__given_invalid_prefix__raises_value_error(self):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(
+                ValueError, match="Invalid US region: 'invalid_prefix/tx'"
+            ):
                 service._setup_region("us", "invalid_prefix/tx")
-            assert "Invalid US region: 'invalid_prefix/tx'" in str(exc_info.value)
 
         def test__given_invalid_bare_value__raises_value_error(self):
             # Bare values without prefix are now invalid (should be normalized first)
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid US region: 'invalid_value'"):
                 service._setup_region("us", "invalid_value")
-            assert "Invalid US region: 'invalid_value'" in str(exc_info.value)
 
         def test__given_place_region__returns_unchanged(self):
             # Test normalized "place/STATE-FIPS" format passes through
@@ -2692,23 +2760,20 @@ def test__given_place_region__returns_unchanged(self):
         def test__given_invalid_place_format__raises_value_error(self):
             # Test place without hyphen raises error
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid place format"):
                 service._setup_region("us", "place/invalid")
-            assert "Invalid place format" in str(exc_info.value)
 
         def test__given_invalid_place_state__raises_value_error(self):
             # Test place with invalid state code raises error
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid state in place code"):
                 service._setup_region("us", "place/XX-57000")
-            assert "Invalid state in place code" in str(exc_info.value)
 
         def test__given_invalid_place_fips__raises_value_error(self):
             # Test place with invalid FIPS code raises error
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid FIPS code"):
                 service._setup_region("us", "place/NJ-abc")
-            assert "Invalid FIPS code" in str(exc_info.value)
 
     class TestDatasetSelection:
         @pytest.mark.parametrize(
@@ -2744,9 +2809,8 @@ def test__given_valid_state_uppercase__does_not_raise(self):
 
         def test__given_invalid_state__raises_value_error(self):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(ValueError, match="Invalid US state: 'mb'"):
                 service._validate_us_region("state/mb")
-            assert "Invalid US state: 'mb'" in str(exc_info.value)
 
         def test__given_valid_congressional_district__does_not_raise(self):
             service = EconomyService()
@@ -2762,15 +2826,17 @@ def test__given_invalid_congressional_district__raises_value_error(
             self,
         ):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(
+                ValueError, match="Invalid congressional district: 'CA-99'"
+            ):
                 service._validate_us_region("congressional_district/CA-99")
-            assert "Invalid congressional district: 'CA-99'" in str(exc_info.value)
 
         def test__given_nonexistent_district__raises_value_error(self):
             service = EconomyService()
-            with pytest.raises(ValueError) as exc_info:
+            with pytest.raises(
+                ValueError, match="Invalid congressional district: 'cruft'"
+            ):
                 service._validate_us_region("congressional_district/cruft")
-            assert "Invalid congressional district: 'cruft'" in str(exc_info.value)
 
 
 class TestBuildOptionsHash:
diff --git a/tests/unit/services/test_household_calculation_service.py b/tests/unit/services/test_household_calculation_service.py
index 25edb586a..508b5cab0 100644
--- a/tests/unit/services/test_household_calculation_service.py
+++ b/tests/unit/services/test_household_calculation_service.py
@@ -1,6 +1,7 @@
 from contextlib import contextmanager
 from pathlib import Path
 from types import SimpleNamespace
+from typing import ClassVar
 from unittest.mock import MagicMock, Mock
 
 import pytest
@@ -111,7 +112,7 @@ def test_calculate_household_preserves_calculation_warnings():
     household = {"people": {"you": {"employment_income": {"2026": None}}}}
 
     class Country:
-        metadata = {
+        metadata: ClassVar[dict] = {
             "variables": {"employment_income": {"entity": "person"}},
             "entities": {"person": {"plural": "people", "roles": {}}},
             "parameters": {},
@@ -138,7 +139,7 @@ def test_parsed_country_calculation_is_reused_for_calculation():
     parsed_calculation = object()
 
     class Country:
-        metadata = {
+        metadata: ClassVar[dict] = {
             "variables": {},
             "entities": {"person": {"plural": "people", "roles": {}}},
             "parameters": {},
@@ -185,7 +186,7 @@ def test_successful_situation_parsing_accepts_calculation_before_stage_ends():
     accepted = Mock()
 
     class Country:
-        metadata = {
+        metadata: ClassVar[dict] = {
             "variables": {},
             "entities": {"person": {"plural": "people", "roles": {}}},
             "parameters": {},
@@ -213,7 +214,7 @@ def test_failed_situation_parsing_does_not_accept_calculation():
     accepted = Mock()
 
     class Country:
-        metadata = {
+        metadata: ClassVar[dict] = {
             "variables": {},
             "entities": {"person": {"plural": "people", "roles": {}}},
             "parameters": {},
@@ -249,7 +250,7 @@ def test_calculation_closes_reads_before_compute_and_caches_atomic_results(
     cache = _cache()
 
     class Country:
-        metadata = {
+        metadata: ClassVar[dict] = {
             "variables": {},
             "entities": {"person": {"plural": "people", "roles": {}}},
         }
diff --git a/tests/unit/services/test_household_service.py b/tests/unit/services/test_household_service.py
index f5ccf53c4..ee1e39947 100644
--- a/tests/unit/services/test_household_service.py
+++ b/tests/unit/services/test_household_service.py
@@ -24,7 +24,8 @@ def service(orm_session_factory):
     return HouseholdService(orm_session_factory)
 
 
-def test_get_household_returns_mapped_entity(service, existing_household_record):
+@pytest.mark.usefixtures("existing_household_record")
+def test_get_household_returns_mapped_entity(service):
     household = service.get_household(
         valid_db_row["country_id"],
         valid_db_row["id"],
@@ -47,7 +48,7 @@ def test_get_household_rejects_invalid_id(service, household_id):
 def test_create_household_adds_mapped_entity(service, monkeypatch):
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "some-hash",
+        lambda _value: "some-hash",
     )
 
     result = service.create_household(
@@ -75,7 +76,7 @@ def test_selected_create_commits_household_and_one_complete_event(
 ) -> None:
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "source-hash",
+        lambda _value: "source-hash",
     )
 
     result = service.create_household(
@@ -106,7 +107,7 @@ def test_selected_create_builds_event_from_refreshed_database_row(
 ) -> None:
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "source-hash",
+        lambda _value: "source-hash",
     )
     original_refresh = orm_session_factory.class_.refresh
 
diff --git a/tests/unit/services/test_metadata_service.py b/tests/unit/services/test_metadata_service.py
index 86423faff..8d72d8eb2 100644
--- a/tests/unit/services/test_metadata_service.py
+++ b/tests/unit/services/test_metadata_service.py
@@ -39,7 +39,7 @@ def test_get_metadata_empty_country_id(self):
             service.get_metadata(empty_country_id)
 
     @pytest.mark.parametrize(
-        "country_id, current_law_id, test_regions",
+        ("country_id", "current_law_id", "test_regions"),
         [
             (
                 "uk",
@@ -141,7 +141,7 @@ def test_default_dataset_matches_policyengine_bundle(self, country_id):
         assert datasets[0]["data_version"] == release["version"]
 
     @pytest.mark.parametrize(
-        "country_id, expected_label",
+        ("country_id", "expected_label"),
         [
             ("us", "Microcosm"),
             ("uk", "Enhanced FRS"),
@@ -157,7 +157,7 @@ def test_default_dataset_uses_user_facing_label(self, country_id, expected_label
         assert dataset["title"] == f"Certified {expected_label} dataset"
 
     @pytest.mark.parametrize(
-        "country_id, expected_types",
+        ("country_id", "expected_types"),
         [
             ("uk", ["national", "country", "constituency", "local_authority"]),
             ("us", ["national", "state", "place", "congressional_district"]),
diff --git a/tests/unit/services/test_policy_service.py b/tests/unit/services/test_policy_service.py
index 5c916bf8e..8077073d6 100644
--- a/tests/unit/services/test_policy_service.py
+++ b/tests/unit/services/test_policy_service.py
@@ -14,7 +14,8 @@ def service(orm_session_factory):
     return PolicyService(orm_session_factory)
 
 
-def test_get_policy_returns_mapped_entity(service, existing_policy_record):
+@pytest.mark.usefixtures("existing_policy_record")
+def test_get_policy_returns_mapped_entity(service):
     policy = service.get_policy(
         valid_policy_data["country_id"],
         valid_policy_data["id"],
@@ -43,7 +44,8 @@ def test_get_policy_rejects_empty_country(service, country_id):
         service.get_policy(country_id, 1)
 
 
-def test_get_policy_json_returns_python_object(service, existing_policy_record):
+@pytest.mark.usefixtures("existing_policy_record")
+def test_get_policy_json_returns_python_object(service):
     result = service.get_policy_json("us", valid_policy_data["id"])
 
     assert result == {
@@ -95,7 +97,7 @@ def test_search_policies_filters_and_deduplicates(service, orm_session_factory):
 def test_set_policy_adds_mapped_entity(service, monkeypatch):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: "new-hash",
+        lambda _value: "new-hash",
     )
 
     result = service.set_policy(
@@ -129,7 +131,7 @@ def test_set_policy_builds_mirror_snapshot_from_refreshed_database_row(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: "new-hash",
+        lambda _value: "new-hash",
     )
     original_refresh = orm_session_factory.class_.refresh
 
@@ -154,14 +156,14 @@ def refresh_with_database_normalization(session, policy, *args, **kwargs):
     assert result.snapshot.policy_json == {"parameter": 0.04094}
 
 
+@pytest.mark.usefixtures("existing_policy_record")
 def test_set_policy_returns_existing_mapped_entity(
     service,
-    existing_policy_record,
     monkeypatch,
 ):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: valid_policy_data["policy_hash"],
+        lambda _value: valid_policy_data["policy_hash"],
     )
 
     result = service.set_policy(
@@ -185,12 +187,12 @@ def test_set_policy_does_not_build_v2_snapshot_unless_requested(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: "new-hash",
+        lambda _value: "new-hash",
     )
     monkeypatch.setattr(
         service._sessions.class_,
         "refresh",
-        lambda *args, **kwargs: pytest.fail("cloud_sql-only writes must not refresh"),
+        lambda *_args, **_kwargs: pytest.fail("cloud_sql-only writes must not refresh"),
     )
 
     result = service.set_policy(
@@ -215,12 +217,12 @@ def test_set_policy_propagates_flush_failure(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.policy_service.hash_object",
-        lambda value: "new-hash",
+        lambda _value: "new-hash",
     )
     monkeypatch.setattr(
         orm_session_factory.class_,
         "flush",
-        lambda self: (_ for _ in ()).throw(SQLAlchemyError("insert failed")),
+        lambda _self: (_ for _ in ()).throw(SQLAlchemyError("insert failed")),
     )
 
     with pytest.raises(SQLAlchemyError, match="insert failed"):
@@ -234,7 +236,7 @@ def test_mirror_snapshot_read_failure_rolls_back_new_v1_policy(
         failing_read.setattr(
             orm_session_factory.class_,
             "refresh",
-            lambda *args, **kwargs: (_ for _ in ()).throw(
+            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                 SQLAlchemyError("snapshot read failed")
             ),
         )
diff --git a/tests/unit/services/test_report_service_owned_sessions.py b/tests/unit/services/test_report_service_owned_sessions.py
index 7bb269ba4..d97346c42 100644
--- a/tests/unit/services/test_report_service_owned_sessions.py
+++ b/tests/unit/services/test_report_service_owned_sessions.py
@@ -74,7 +74,7 @@ def test_create_rolls_back_all_rows_when_dual_write_fails(
     orm_session_factory,
     monkeypatch,
 ):
-    def fail_dual_write(*args, **kwargs):
+    def fail_dual_write(*_args, **_kwargs):
         msg = "report dual write failed"
         raise RuntimeError(msg)
 
diff --git a/tests/unit/services/test_service_owned_sessions.py b/tests/unit/services/test_service_owned_sessions.py
index 52cb9bf73..5e372b51c 100644
--- a/tests/unit/services/test_service_owned_sessions.py
+++ b/tests/unit/services/test_service_owned_sessions.py
@@ -69,7 +69,7 @@ def test_core_services_commit_writes_and_return_generated_ids(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "household-hash",
+        lambda _value: "household-hash",
     )
     service = HouseholdService(orm_session_factory)
 
@@ -92,7 +92,7 @@ def test_core_services_roll_back_failed_writes(
 ):
     monkeypatch.setattr(
         "policyengine_api.services.household_service.hash_object",
-        lambda value: "household-hash",
+        lambda _value: "household-hash",
     )
     session_type = orm_session_factory.class_
     original_flush = session_type.flush
diff --git a/tests/unit/services/test_simulation_service.py b/tests/unit/services/test_simulation_service.py
index 4520f30f8..7fd9119c3 100644
--- a/tests/unit/services/test_simulation_service.py
+++ b/tests/unit/services/test_simulation_service.py
@@ -87,7 +87,7 @@ def test_get_or_create_rolls_back_simulation_when_dual_write_fails(
     orm_session_factory,
     monkeypatch,
 ):
-    def fail_dual_write(*args, **kwargs):
+    def fail_dual_write(*_args, **_kwargs):
         msg = "dual write sync failed"
         raise RuntimeError(msg)
 
diff --git a/tests/unit/services/test_spm_household_identity.py b/tests/unit/services/test_spm_household_identity.py
index 4a4286ac8..7927f66b5 100644
--- a/tests/unit/services/test_spm_household_identity.py
+++ b/tests/unit/services/test_spm_household_identity.py
@@ -66,7 +66,7 @@ def test_uk_household_population_ids_keep_their_existing_representation(
     assert created.simulation.simulation_spec_json["population_id"] == "0001"
 
 
-@pytest.mark.parametrize("unrelated_id", ["1suffix", "1.0", "+1", " 1", "1\n", "١"])
+@pytest.mark.parametrize("unrelated_id", ["1suffix", "1.0", "+1", " 1", "1\n", "١"])  # noqa: RUF001  # non-ASCII digits are the input under test
 def test_numeric_alias_lookup_does_not_reuse_nonnumeric_population_ids(
     orm_session_factory, unrelated_id
 ):
diff --git a/tests/unit/services/test_user_policy_service.py b/tests/unit/services/test_user_policy_service.py
index f36244427..d3c7500d9 100644
--- a/tests/unit/services/test_user_policy_service.py
+++ b/tests/unit/services/test_user_policy_service.py
@@ -77,7 +77,7 @@ def test_policy_routes_do_not_manage_sessions_or_queries():
 
 @pytest.mark.parametrize(
     ("error", "expected_category", "expected_retryable"),
-    (
+    [
         (
             SQLAlchemyTimeoutError("credential=timeout-secret"),
             "timeout",
@@ -103,7 +103,7 @@ def test_policy_routes_do_not_manage_sessions_or_queries():
         ),
         (SQLAlchemyError("database-secret"), "database", False),
         (RuntimeError("unexpected-secret"), "unexpected", False),
-    ),
+    ],
 )
 def test_saved_policy_service_translates_failures_to_safe_domain_errors(
     error,
@@ -123,7 +123,12 @@ def test_saved_policy_service_translates_failures_to_safe_domain_errors(
 
 
 def test_saved_policy_persistence_failure_category_is_allowlisted() -> None:
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError,
+        match=(
+            "'raw-exception-text' is not a valid UserPolicyPersistenceFailureCategory"
+        ),
+    ):
         UserPolicyPersistenceError("raw-exception-text")  # type: ignore[arg-type]
 
 
@@ -393,7 +398,7 @@ def test_failed_processing_retains_the_oldest_pending_event(orm_session_factory)
             "us",
             created.user_policy.id,
             through_revision=created.mirror_revision,
-            processor=lambda event: (_ for _ in ()).throw(
+            processor=lambda _event: (_ for _ in ()).throw(
                 RuntimeError("Supabase unavailable")
             ),
         )
@@ -462,5 +467,5 @@ def test_corrupt_event_changed_fields_are_rejected(orm_session_factory):
             "us",
             created.user_policy.id,
             through_revision=created.mirror_revision,
-            processor=lambda event: None,
+            processor=lambda _event: None,
         )
diff --git a/tests/unit/services/test_user_service.py b/tests/unit/services/test_user_service.py
index 0f27836b3..421ff11a2 100644
--- a/tests/unit/services/test_user_service.py
+++ b/tests/unit/services/test_user_service.py
@@ -24,9 +24,9 @@ def test_get_profile_returns_none_for_unknown_auth0_id(service):
     assert service.get_profile(auth0_id="missing") is None
 
 
+@pytest.mark.usefixtures("existing_user_profile")
 def test_get_profile_returns_mapped_entity_by_either_identifier(
     service,
-    existing_user_profile,
 ):
     by_auth0 = service.get_profile(
         auth0_id=valid_user_record["auth0_id"],
@@ -64,9 +64,9 @@ def test_update_profile_returns_none_for_missing_entity(service):
     assert service.update_profile(999, "uk", "missing", 2) is None
 
 
+@pytest.mark.usefixtures("existing_user_profile")
 def test_update_profile_only_changes_non_null_fields(
     service,
-    existing_user_profile,
 ):
     profile = service.update_profile(
         valid_user_record["user_id"],
diff --git a/tests/unit/services/test_worker_spm.py b/tests/unit/services/test_worker_spm.py
index 7a1304059..04eae56e2 100644
--- a/tests/unit/services/test_worker_spm.py
+++ b/tests/unit/services/test_worker_spm.py
@@ -14,12 +14,14 @@
 
 @pytest.mark.parametrize("selection", [None, {"geography_kind": "national"}])
 def test_canonical_worker_selection_is_rejected_including_resolved_default(selection):
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection",
-        return_value={"geography_kind": "national"},
-    ) as normalize:
-        with pytest.raises(SPMValidationError) as error:
-            validate_worker_spm("us", selection)
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value={"geography_kind": "national"},
+        ) as normalize,
+        pytest.raises(SPMValidationError) as error,
+    ):
+        validate_worker_spm("us", selection)
     normalize.assert_called_once_with("us", selection)
     assert error.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
 
@@ -36,27 +38,31 @@ def test_legacy_worker_selection_remains_usable(country_id):
 def test_actual_settings_validator_rejects_explicit_settings_on_legacy_worker(
     country_id,
 ):
-    with patch(
-        "policyengine_api.spm._current_bundle",
-        return_value={
-            "policyengine_version": "5.2.0",
-            "packages": {"policyengine-us": {"version": "1.764.6"}},
-        },
+    with (
+        patch(
+            "policyengine_api.spm._current_bundle",
+            return_value={
+                "policyengine_version": "5.2.0",
+                "packages": {"policyengine-us": {"version": "1.764.6"}},
+            },
+        ),
+        patch("policyengine_api.spm.simulation_supports_spm", return_value=False),
     ):
-        with patch("policyengine_api.spm.simulation_supports_spm", return_value=False):
-            assert validate_worker_spm(country_id) is None
-            with pytest.raises(SPMValidationError) as error:
-                validate_worker_spm(country_id, {"geography_kind": "national"})
+        assert validate_worker_spm(country_id) is None
+        with pytest.raises(SPMValidationError) as error:
+            validate_worker_spm(country_id, {"geography_kind": "national"})
     assert error.value.code == "SPM_SETTINGS_UNSUPPORTED"
 
 
 @pytest.mark.parametrize("country_id", ["us", "US"])
 def test_uncertified_canonical_bundle_cannot_default_to_legacy_worker(country_id):
     """A model that can run canonical SPM never reaches a worker uncertified."""
-    with patch("policyengine_api.spm._current_bundle", return_value={}):
-        with patch("policyengine_api.spm.simulation_supports_spm", return_value=True):
-            with pytest.raises(SPMValidationError) as error:
-                validate_worker_spm(country_id)
+    with (
+        patch("policyengine_api.spm._current_bundle", return_value={}),
+        patch("policyengine_api.spm.simulation_supports_spm", return_value=True),
+        pytest.raises(SPMValidationError) as error,
+    ):
+        validate_worker_spm(country_id)
     assert error.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
 
 
@@ -68,11 +74,13 @@ def test_unconfigured_bundle_keeps_the_legacy_worker_path(country_id):
     every economy request.
     """
     gateway = Mock()
-    with patch("policyengine_api.spm._current_bundle", return_value={}):
-        with patch("policyengine_api.spm.simulation_supports_spm", return_value=False):
-            assert validate_worker_spm(country_id, gateway=gateway) is None
-            with pytest.raises(SPMValidationError) as error:
-                validate_worker_spm(country_id, {"geography_kind": "national"})
+    with (
+        patch("policyengine_api.spm._current_bundle", return_value={}),
+        patch("policyengine_api.spm.simulation_supports_spm", return_value=False),
+    ):
+        assert validate_worker_spm(country_id, gateway=gateway) is None
+        with pytest.raises(SPMValidationError) as error:
+            validate_worker_spm(country_id, {"geography_kind": "national"})
     assert error.value.code == "SPM_SETTINGS_UNSUPPORTED"
     gateway.get_spm_capability.assert_not_called()
 
@@ -101,12 +109,14 @@ def test_canonical_economy_request_fails_before_cache_lookup(budget_window, opti
         call = service.get_economic_impact
         arguments["time_period"] = "2026"
 
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection",
-        return_value={"geography_kind": "county"},
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value={"geography_kind": "county"},
+        ),
+        pytest.raises(SPMValidationError),
     ):
-        with pytest.raises(SPMValidationError):
-            call(**arguments)
+        call(**arguments)
 
     assert not service._injected_budget_window_cache.mock_calls
     assert not service._injected_reform_impacts_service.mock_calls
@@ -124,12 +134,14 @@ def test_canonical_direct_submission_fails_before_transport(method, selection):
     if selection is not None:
         payload["spm"] = selection
 
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection",
-        return_value={"geography_kind": "county"},
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value={"geography_kind": "county"},
+        ),
+        pytest.raises(SPMValidationError),
     ):
-        with pytest.raises(SPMValidationError):
-            getattr(client, method)(payload)
+        getattr(client, method)(payload)
 
     client.client.post.assert_not_called()
 
@@ -145,14 +157,16 @@ def test_canonical_economy_errors_use_existing_validation_envelope(path):
     app = Flask(__name__)
     app.register_blueprint(economy_bp)
     app.config["TESTING"] = True
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection",
-        return_value={"geography_kind": "county"},
-    ):
-        with patch.object(
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value={"geography_kind": "county"},
+        ),
+        patch.object(
             SimulationEntrypointClient, "get_spm_capability", return_value=None
-        ):
-            response = app.test_client().get(path)
+        ),
+    ):
+        response = app.test_client().get(path)
 
     assert response.status_code == 400
     payload = response.get_json()
@@ -259,15 +273,18 @@ def test_certified_worker_selection_enters_identity_and_submission():
 def test_uncertified_or_mismatching_worker_is_rejected(capability):
     gateway = Mock()
     gateway.get_spm_capability.return_value = capability
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection", return_value=SELECTION
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value=SELECTION,
+        ),
+        pytest.raises(SPMValidationError),
     ):
-        with pytest.raises(SPMValidationError):
-            validate_worker_spm("us", gateway=gateway, policyengine_version="test-only")
+        validate_worker_spm("us", gateway=gateway, policyengine_version="test-only")
 
 
 @pytest.mark.parametrize(
-    "method,path",
+    ("method", "path"),
     [
         ("run", "/simulate/economy/comparison"),
         ("run_budget_window_batch", "/simulate/economy/budget-window"),
@@ -403,14 +420,16 @@ def handle(request):
 
 def test_canonical_submission_rejects_mutable_latest_bundle_alias():
     client = object.__new__(SimulationEntrypointClient)
-    with patch(
-        "policyengine_api.libs.simulation_entrypoint.validate_worker_spm",
-        return_value=SELECTION,
+    with (
+        patch(
+            "policyengine_api.libs.simulation_entrypoint.validate_worker_spm",
+            return_value=SELECTION,
+        ),
+        pytest.raises(SPMValidationError, match="exact PolicyEngine version"),
     ):
-        with pytest.raises(SPMValidationError, match="exact PolicyEngine version"):
-            client._normalize_submission_payload(
-                {"country": "us", "policyengine_version": "latest"}
-            )
+        client._normalize_submission_payload(
+            {"country": "us", "policyengine_version": "latest"}
+        )
 
 
 @pytest.mark.parametrize(
@@ -427,7 +446,7 @@ def test_typed_worker_poll_errors_reach_api_validation(code, method):
     client.base_url = "http://test"
     client.client = httpx.Client(
         transport=httpx.MockTransport(
-            lambda request: httpx.Response(
+            lambda _request: httpx.Response(
                 400,
                 json={
                     "status": "failed",
@@ -674,11 +693,14 @@ def test_a_worker_capability_failure_quotes_no_validator_internals(capability):
     """
     gateway = Mock()
     gateway.get_spm_capability.return_value = capability
-    with patch(
-        "policyengine_api.worker_spm.normalize_spm_selection", return_value=SELECTION
+    with (
+        patch(
+            "policyengine_api.worker_spm.normalize_spm_selection",
+            return_value=SELECTION,
+        ),
+        pytest.raises(SPMValidationError) as caught,
     ):
-        with pytest.raises(SPMValidationError) as caught:
-            validate_worker_spm("us", gateway=gateway, policyengine_version="test-only")
+        validate_worker_spm("us", gateway=gateway, policyengine_version="test-only")
     assert caught.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
     assert not any(part in caught.value.message for part in PYDANTIC_INTERNALS)
     assert caught.value.message
diff --git a/tests/unit/test_asgi_factory.py b/tests/unit/test_asgi_factory.py
index b309ba2bc..51aaa3d7a 100644
--- a/tests/unit/test_asgi_factory.py
+++ b/tests/unit/test_asgi_factory.py
@@ -272,7 +272,7 @@ def test_native_readiness_uses_shared_asgi_middleware():
 def test_native_route_preserves_request_id_in_context_log_and_response():
     observed_context_ids = []
 
-    def capture_request(**kwargs):
+    def capture_request(**_kwargs):
         observed_context_ids.append(current_request_id())
 
     with patch(
@@ -292,7 +292,7 @@ def capture_request(**kwargs):
 def test_native_route_generates_one_request_id_for_context_log_and_response():
     observed_context_ids = []
 
-    def capture_request(**kwargs):
+    def capture_request(**_kwargs):
         observed_context_ids.append(current_request_id())
 
     with (
diff --git a/tests/unit/test_capture_migration_baseline.py b/tests/unit/test_capture_migration_baseline.py
index 4d7c75a92..b7e1c73b2 100644
--- a/tests/unit/test_capture_migration_baseline.py
+++ b/tests/unit/test_capture_migration_baseline.py
@@ -101,7 +101,7 @@ def test_run_probes_treats_unexpected_4xx_as_failure(monkeypatch):
         "Client",
         lambda **kwargs: real_client(
             transport=httpx.MockTransport(
-                lambda request: httpx.Response(404, json={"status": "missing"})
+                lambda _request: httpx.Response(404, json={"status": "missing"})
             ),
             base_url=kwargs["base_url"],
             timeout=kwargs["timeout"],
diff --git a/tests/unit/test_ci_complete_gate.py b/tests/unit/test_ci_complete_gate.py
index 618d05720..74c7769b8 100644
--- a/tests/unit/test_ci_complete_gate.py
+++ b/tests/unit/test_ci_complete_gate.py
@@ -40,8 +40,10 @@ def gate_violations(workflow: dict) -> list[str]:
     gated_jobs = gate.get("needs") or []
     if isinstance(gated_jobs, str):
         gated_jobs = [gated_jobs]
-    for job_id in sorted(set(jobs) - {GATE_JOB} - set(gated_jobs)):
-        violations.append(f"{GATE_JOB} does not need {job_id}")
+    violations.extend(
+        f"{GATE_JOB} does not need {job_id}"
+        for job_id in sorted(set(jobs) - {GATE_JOB} - set(gated_jobs))
+    )
 
     for job_id, job in jobs.items():
         if job_id == GATE_JOB:
diff --git a/tests/unit/test_compare_migration_baseline.py b/tests/unit/test_compare_migration_baseline.py
index 753fbec64..6160c72a4 100644
--- a/tests/unit/test_compare_migration_baseline.py
+++ b/tests/unit/test_compare_migration_baseline.py
@@ -7,7 +7,7 @@ def _summary(rows):
     return capture_migration_baseline.summarize(rows)
 
 
-def _probe(name, latency_ms, ok=True, **kwargs):
+def _probe(name, latency_ms, *, ok=True, **kwargs):
     return capture_migration_baseline.ProbeResult(
         name=name,
         method="GET",
@@ -101,7 +101,7 @@ def test_compare_fails_on_probe_missing_from_candidate():
 
 
 def test_compare_gates_completion_rows_as_pseudo_probe():
-    def completion(ms, completed=True):
+    def completion(ms, *, completed=True):
         return _probe(
             "simulation_gateway_completion",
             5.0,
diff --git a/tests/unit/test_constants.py b/tests/unit/test_constants.py
index 33a4040c8..e467d0ae9 100644
--- a/tests/unit/test_constants.py
+++ b/tests/unit/test_constants.py
@@ -21,7 +21,7 @@
 
 class TestBundleDatasetDisplayLabels:
     @pytest.mark.parametrize(
-        "dataset_name, expected_label",
+        ("dataset_name", "expected_label"),
         [
             ("populace_us_2024", "Microcosm"),
             ("enhanced_frs_2024_25", "Enhanced FRS"),
@@ -233,7 +233,7 @@ def test__load_policyengine_bundle_rejects_non_object_manifest(
 
     def test__uses_policyengine_bundle_versions_for_us_uk_and_core(self):
         expected_versions = self._expected_bundle_versions()
-        assert POLICYENGINE_VERSION == expected_versions["policyengine"]
-        assert POLICYENGINE_CORE_VERSION == expected_versions["core"]
+        assert expected_versions["policyengine"] == POLICYENGINE_VERSION
+        assert expected_versions["core"] == POLICYENGINE_CORE_VERSION
         assert COUNTRY_PACKAGE_VERSIONS["us"] == expected_versions["us"]
         assert COUNTRY_PACKAGE_VERSIONS["uk"] == expected_versions["uk"]
diff --git a/tests/unit/test_country.py b/tests/unit/test_country.py
index b9577320b..75a6b3321 100644
--- a/tests/unit/test_country.py
+++ b/tests/unit/test_country.py
@@ -47,18 +47,18 @@ def calculate(self, variable_name, period):
                 return np.array([40])
 
             def get_population(self, entity_plural):
-                return SimpleNamespace(get_index=lambda entity_id: 0)
+                return SimpleNamespace(get_index=lambda _entity_id: 0)
 
         variable = SimpleNamespace(value_type=int)
         system = SimpleNamespace(
             variables={"age": variable},
-            get_variable=lambda variable_name: variable,
+            get_variable=lambda _variable_name: variable,
         )
         country = PolicyEngineCountry.__new__(PolicyEngineCountry)
         monkeypatch.setattr(
             country,
             "_create_simulation",
-            lambda household, reform, **kwargs: (SimulationWithoutTracing(), system),
+            lambda _household, _reform, **_kwargs: (SimulationWithoutTracing(), system),
         )
 
         result = country.calculate(
@@ -161,13 +161,13 @@ def get_population(self, entity_plural):
         variable = SimpleNamespace(value_type=float)
         system = SimpleNamespace(
             variables={"employment_income": variable},
-            get_variable=lambda variable_name: variable,
+            get_variable=lambda _variable_name: variable,
         )
         country = PolicyEngineCountry.__new__(PolicyEngineCountry)
         monkeypatch.setattr(
             country,
             "_create_simulation",
-            lambda household, reform, **kwargs: (BrokenSimulation(), system),
+            lambda _household, _reform, **_kwargs: (BrokenSimulation(), system),
         )
         household = {
             "people": {"you": {"employment_income": {"2025": None}}},
@@ -264,7 +264,7 @@ def test__uk_still_has_constituencies(self, uk_regions):
 
     def test__uk_has_all_region_types(self, uk_regions):
         """Verify all expected region types are present."""
-        types = set(r.get("type") for r in uk_regions)
+        types = {r.get("type") for r in uk_regions}
         assert "national" in types
         assert "country" in types
         assert "constituency" in types
diff --git a/tests/unit/test_country_spm.py b/tests/unit/test_country_spm.py
index 2b7666539..fbbb0f868 100644
--- a/tests/unit/test_country_spm.py
+++ b/tests/unit/test_country_spm.py
@@ -48,22 +48,22 @@ def requested_household(variable="spm_unit_spm_threshold", *, axes=False):
 def _country_raising(monkeypatch, error):
     """Return a country whose every variable calculation raises `error`."""
 
-    def calculate(variable, period):
+    def calculate(_variable, _period):
         # This also represents a requested resource with a nested SPM dependency.
         raise error
 
     simulation = SimpleNamespace(
         calculate=calculate,
-        get_population=lambda entity: SimpleNamespace(
-            get_index=lambda entity_id: 0, count=AXIS_POINTS
+        get_population=lambda _entity: SimpleNamespace(
+            get_index=lambda _entity_id: 0, count=AXIS_POINTS
         ),
     )
     system = SimpleNamespace(
-        get_variable=lambda name: object(), variables=HOUSEHOLD_VARIABLES
+        get_variable=lambda _name: object(), variables=HOUSEHOLD_VARIABLES
     )
     country = PolicyEngineCountry.__new__(PolicyEngineCountry)
     monkeypatch.setattr(
-        country, "_create_simulation", lambda *args, **kwargs: (simulation, system)
+        country, "_create_simulation", lambda *_args, **_kwargs: (simulation, system)
     )
     return country
 
@@ -80,7 +80,9 @@ def test_country_never_swallows_spm_input_errors_for_a_chosen_measurement(
     monkeypatch, code, axes
 ):
     country, error = _failing_country(monkeypatch, code)
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(
+        ValueError, match="Missing or unavailable explicit SPM input"
+    ) as caught:
         country.calculate(
             requested_household("spm_unit_net_income", axes=axes),
             None,
@@ -120,21 +122,21 @@ def test_an_inherited_measurement_still_returns_the_rest_of_the_calculation(
     error = ValueError("Missing or unavailable explicit SPM input")
     error.code = "SPM_GEOGRAPHY_REQUIRED"
 
-    def calculate(variable, period):
+    def calculate(variable, _period):
         if variable == "spm_unit_net_income":
             raise error
         return np.array([1234.0])
 
     simulation = SimpleNamespace(
         calculate=calculate,
-        get_population=lambda entity: SimpleNamespace(get_index=lambda entity_id: 0),
+        get_population=lambda _entity: SimpleNamespace(get_index=lambda _entity_id: 0),
     )
     system = SimpleNamespace(
-        get_variable=lambda name: SimpleNamespace(value_type=float)
+        get_variable=lambda _name: SimpleNamespace(value_type=float)
     )
     country = PolicyEngineCountry.__new__(PolicyEngineCountry)
     monkeypatch.setattr(
-        country, "_create_simulation", lambda *args, **kwargs: (simulation, system)
+        country, "_create_simulation", lambda *_args, **_kwargs: (simulation, system)
     )
 
     household = requested_household("spm_unit_net_income")
@@ -173,7 +175,7 @@ def test_country_passes_resolved_spm_and_uses_the_simulations_private_system(
 ):
     selection = spm.SPMSelection(geography_kind="national").model_dump()
     monkeypatch.setattr(
-        country_module, "normalize_spm_selection", lambda country, chosen: selection
+        country_module, "normalize_spm_selection", lambda _country, _chosen: selection
     )
 
     class Simulation:
@@ -218,23 +220,23 @@ def test_tax_only_result_reads_provenance_without_calculating_spm(monkeypatch):
         "storage_method": "test final cast",
     }
 
-    def calculate(variable, period):
+    def calculate(variable, _period):
         calculations.append(variable)
         assert variable == "spm_unit_federal_tax"
         return np.array([123.0])
 
     simulation = SimpleNamespace(
         calculate=calculate,
-        get_population=lambda entity: SimpleNamespace(get_index=lambda entity_id: 0),
+        get_population=lambda _entity: SimpleNamespace(get_index=lambda _entity_id: 0),
         spm_config=selection,
         spm_provenance=lambda: receipt,
     )
     system = SimpleNamespace(
-        get_variable=lambda name: SimpleNamespace(value_type=float)
+        get_variable=lambda _name: SimpleNamespace(value_type=float)
     )
     country = PolicyEngineCountry.__new__(PolicyEngineCountry)
     monkeypatch.setattr(
-        country, "_create_simulation", lambda *args, **kwargs: (simulation, system)
+        country, "_create_simulation", lambda *_args, **_kwargs: (simulation, system)
     )
     result = country.calculate(requested_household("spm_unit_federal_tax"), None)
     assert calculations == ["spm_unit_federal_tax"]
@@ -302,7 +304,9 @@ def test_real_country_state_only_spm_dependency_requires_geography(
     real_canonical_country, variable
 ):
     """A household that chose this measurement is told what it is missing."""
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(
+        ValueError, match="County selection has no county FIPS input"
+    ) as caught:
         real_canonical_country.calculate(
             requested_household(variable), None, spm_requested=True
         )
@@ -339,13 +343,19 @@ def test_real_country_unknown_county_is_structured(
 ):
     household = requested_household()
     household["households"]["household"]["county_fips"] = {"2024": county}
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(
+        ValueError,
+        match=r"County (assignment unavailable|selection has no county FIPS input)",
+    ) as caught:
         real_canonical_country.calculate(household, None, spm_requested=True)
     assert spm.spm_error_detail(caught.value)["code"] == expected_code
 
 
 def test_real_country_unknown_area_is_structured(real_canonical_country):
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(
+        ValueError,
+        match="SPM area is unavailable in the selected artifact: unknown-area",
+    ) as caught:
         real_canonical_country.calculate(
             requested_household(),
             None,
@@ -358,7 +368,7 @@ def test_real_country_unknown_area_is_structured(real_canonical_country):
 def test_real_country_unclassified_composition_is_structured(real_canonical_country):
     household = requested_household()
     household["people"]["you"]["age"] = {"2024": 14}
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(ValueError, match="SPM unit has no classified adult") as caught:
         real_canonical_country.calculate(
             household, None, spm={"geography_kind": "national"}, spm_requested=True
         )
@@ -452,7 +462,7 @@ def test_real_http_tax_only_succeeds_without_geography(real_http_client):
 
 
 @pytest.mark.parametrize(
-    "kind,code",
+    ("kind", "code"),
     [
         ("state-only", "SPM_GEOGRAPHY_REQUIRED"),
         ("axes", "SPM_GEOGRAPHY_REQUIRED"),
@@ -652,17 +662,17 @@ def test_uncertifiable_country_receipt_does_not_become_an_internal_failure(monke
     """
     selection = spm.SPMSelection(geography_kind="national").model_dump()
     simulation = SimpleNamespace(
-        calculate=lambda variable, period: np.array([123.0]),
-        get_population=lambda entity: SimpleNamespace(get_index=lambda entity_id: 0),
+        calculate=lambda _variable, _period: np.array([123.0]),
+        get_population=lambda _entity: SimpleNamespace(get_index=lambda _entity_id: 0),
         spm_config={**selection, "threshold_method": "unreviewed"},
         spm_provenance=dict,
     )
     system = SimpleNamespace(
-        get_variable=lambda name: SimpleNamespace(value_type=float)
+        get_variable=lambda _name: SimpleNamespace(value_type=float)
     )
     country = PolicyEngineCountry.__new__(PolicyEngineCountry)
     monkeypatch.setattr(
-        country, "_create_simulation", lambda *args, **kwargs: (simulation, system)
+        country, "_create_simulation", lambda *_args, **_kwargs: (simulation, system)
     )
     with pytest.raises(spm.SPMValidationError) as caught:
         country.calculate(requested_household("spm_unit_federal_tax"), None)
diff --git a/tests/unit/test_population_identity.py b/tests/unit/test_population_identity.py
index aa9b78ec8..6cbc537ed 100644
--- a/tests/unit/test_population_identity.py
+++ b/tests/unit/test_population_identity.py
@@ -7,15 +7,15 @@
 
 
 @pytest.mark.parametrize(
-    "stored,requested,expected",
+    ("stored", "requested", "expected"),
     [
         ("1 ", "1", False),
         ("1", "1 ", False),
         ("1 ", "1 ", True),
         ("00001", "1", True),
         ("1\n", "1", False),
-        ("１", "1", False),
-        ("1", "１", False),
+        ("１", "1", False),  # noqa: RUF001  # non-ASCII digits are the input under test
+        ("1", "１", False),  # noqa: RUF001  # non-ASCII digits are the input under test
     ],
 )
 def test_sql_alias_matching_is_strict_even_with_permissive_text_collation(
diff --git a/tests/unit/test_query_parameters.py b/tests/unit/test_query_parameters.py
index 11a906758..97b2823eb 100644
--- a/tests/unit/test_query_parameters.py
+++ b/tests/unit/test_query_parameters.py
@@ -108,7 +108,7 @@ def test_policyengine_version_must_be_canonical(version: str) -> None:
 def test_duplicate_scalar_is_rejected_and_explicit_list_is_preserved() -> None:
     with pytest.raises(
         DuplicateScalarQueryParameterError,
-        match="country_id.*must not be repeated",
+        match=r"country_id.*must not be repeated",
     ):
         parse_query_items(
             PolicyCollectionQuery,
diff --git a/tests/unit/test_readiness.py b/tests/unit/test_readiness.py
index 7656953ff..0cd745c18 100644
--- a/tests/unit/test_readiness.py
+++ b/tests/unit/test_readiness.py
@@ -147,7 +147,7 @@ def test_readiness_accepts_a_certified_measurement_configuration(monkeypatch):
     monkeypatch.setattr(
         spm,
         "_selected_forecast",
-        lambda _: SimpleNamespace(years=[2026], entry=lambda *a, **k: {}),
+        lambda _: SimpleNamespace(years=[2026], entry=lambda *_args, **_kwargs: {}),
     )
     bundle = {
         "measurements": {
diff --git a/tests/unit/test_spm_settings.py b/tests/unit/test_spm_settings.py
index 1690da847..f754de006 100644
--- a/tests/unit/test_spm_settings.py
+++ b/tests/unit/test_spm_settings.py
@@ -26,7 +26,7 @@ def certified_bundle(monkeypatch):
     monkeypatch.setattr(spm, "_current_bundle", lambda: bundle)
     monkeypatch.setattr(spm, "simulation_supports_spm", lambda _: True)
 
-    def entry(year, *, scenario, as_of):
+    def entry(_year, *, scenario, as_of):
         if scenario not in {"baseline", "alternative"}:
             msg = "Unknown forecast scenario"
             raise ValueError(msg)
@@ -35,7 +35,7 @@ def entry(year, *, scenario, as_of):
             raise ValueError(msg)
         return {}
 
-    def geography_factor(year, tenure, *, geoid, **kwargs):
+    def geography_factor(_year, _tenure, *, geoid, **_kwargs):
         if geoid != "31080":
             msg = "Forecast geography unavailable"
             raise ValueError(msg)
@@ -44,7 +44,7 @@ def geography_factor(year, tenure, *, geoid, **kwargs):
     forecast = SimpleNamespace(
         years=(2022, 2035), entry=entry, geography_factor=geography_factor
     )
-    monkeypatch.setattr(spm, "_selected_forecast", lambda expected: forecast)
+    monkeypatch.setattr(spm, "_selected_forecast", lambda _expected: forecast)
     return bundle
 
 
@@ -145,9 +145,8 @@ def test_measurementless_bundle_shapes_read_as_unconfigured(monkeypatch, measure
     assert caught.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
 
 
-def test_default_and_explicit_default_have_identical_resolved_identity(
-    certified_bundle,
-):
+@pytest.mark.usefixtures("certified_bundle")
+def test_default_and_explicit_default_have_identical_resolved_identity():
     defaults = spm.normalize_spm_selection("us", None)
     assert defaults == spm.normalize_spm_selection("us", {})
     assert defaults == spm.normalize_spm_selection(
@@ -172,7 +171,8 @@ def test_default_and_explicit_default_have_identical_resolved_identity(
         {"as_of": "2026-09-09"},
     ],
 )
-def test_selection_changes_resolved_request_identity(certified_bundle, selection):
+@pytest.mark.usefixtures("certified_bundle")
+def test_selection_changes_resolved_request_identity(selection):
     default = spm.normalize_spm_selection("us", None)
     chosen = spm.normalize_spm_selection("us", selection)
     assert chosen != default
@@ -192,9 +192,8 @@ def test_selection_changes_resolved_request_identity(certified_bundle, selection
         {"unreviewed_setting": True},
     ],
 )
-def test_invalid_selected_artifact_settings_have_structured_error(
-    certified_bundle, selection
-):
+@pytest.mark.usefixtures("certified_bundle")
+def test_invalid_selected_artifact_settings_have_structured_error(selection):
     with pytest.raises(spm.SPMValidationError) as caught:
         spm.normalize_spm_selection("us", selection)
     assert caught.value.code == "SPM_SETTINGS_INVALID"
@@ -208,9 +207,8 @@ def test_certification_requires_pinned_artifact_hash(certified_bundle):
     assert caught.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
 
 
-def test_mismatched_installed_artifact_cannot_enable_metadata(
-    certified_bundle, monkeypatch
-):
+@pytest.mark.usefixtures("certified_bundle")
+def test_mismatched_installed_artifact_cannot_enable_metadata(monkeypatch):
     def mismatched_artifact(expected):
         assert expected == ARTIFACT_HASH
         msg = "Forecast content SHA256 mismatch"
@@ -223,21 +221,24 @@ def mismatched_artifact(expected):
     assert spm.spm_metadata("us") == {"available": False}
 
 
-def test_legacy_country_cannot_enable_certified_settings(certified_bundle, monkeypatch):
+@pytest.mark.usefixtures("certified_bundle")
+def test_legacy_country_cannot_enable_certified_settings(monkeypatch):
     monkeypatch.setattr(spm, "simulation_supports_spm", lambda _: False)
     with pytest.raises(spm.SPMValidationError) as caught:
         spm.normalize_spm_selection("us", None)
     assert caught.value.code == "SPM_CONFIGURATION_UNAVAILABLE"
 
 
-def test_metadata_exposes_typed_defaults_only_when_available(certified_bundle):
+@pytest.mark.usefixtures("certified_bundle")
+def test_metadata_exposes_typed_defaults_only_when_available():
     result = spm.spm_metadata("us")
     assert result["available"] is True
     assert result["defaults"] == spm.normalize_spm_selection("us", None)
     assert result["settings_schema"] == spm.SPMSelection.model_json_schema()
 
 
-def test_selected_area_must_exist_in_artifact(certified_bundle):
+@pytest.mark.usefixtures("certified_bundle")
+def test_selected_area_must_exist_in_artifact():
     with pytest.raises(spm.SPMValidationError) as caught:
         spm.normalize_spm_selection(
             "us", {"geography_kind": "metro", "geography_id": "unknown-area"}
@@ -245,8 +246,9 @@ def test_selected_area_must_exist_in_artifact(certified_bundle):
     assert caught.value.code == "SPM_GEOGRAPHY_UNAVAILABLE"
 
 
-def test_area_available_in_later_year_can_be_selected(certified_bundle, monkeypatch):
-    def geography_factor(year, tenure, **kwargs):
+@pytest.mark.usefixtures("certified_bundle")
+def test_area_available_in_later_year_can_be_selected(monkeypatch):
+    def geography_factor(year, _tenure, **_kwargs):
         if year < 2025:
             msg = "Area unavailable before the boundary changed"
             raise ValueError(msg)
@@ -254,7 +256,7 @@ def geography_factor(year, tenure, **kwargs):
 
     forecast = SimpleNamespace(
         years=(2022, 2035),
-        entry=lambda *args, **kwargs: {},
+        entry=lambda *_args, **_kwargs: {},
         geography_factor=geography_factor,
     )
     monkeypatch.setattr(spm, "_selected_forecast", lambda _: forecast)
@@ -273,21 +275,21 @@ def _raise_missing_forecast_year():
 
 @pytest.mark.parametrize("wrapped", [False, True])
 def test_missing_forecast_year_message_alone_does_not_reclassify_errors(wrapped):
-    try:
+    with pytest.raises(ValueError, match="Forecast has no entry for 2036") as caught:
         _raise_missing_forecast_year()
-    except ValueError as error:
-        if wrapped:
-            outer = RuntimeError("An unrelated dependency failed")
-            outer.__cause__ = error
-            error = outer
-        assert spm.spm_error_detail(error) is None
+    error: BaseException = caught.value
+    if wrapped:
+        outer = RuntimeError("An unrelated dependency failed")
+        outer.__cause__ = caught.value
+        error = outer
+    assert spm.spm_error_detail(error) is None
 
 
 def test_plain_forecast_missing_year_is_not_reclassified():
     forecast_module = pytest.importorskip("spm_calculator.rolling_forecast")
     forecast = forecast_module.load_forecast()
     year = max(forecast.years) + 1
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(ValueError, match=f"Forecast has no entry for {year}") as caught:
         forecast.entry(year)
     assert spm.spm_error_detail(caught.value) is None
 
@@ -295,7 +297,9 @@ def test_plain_forecast_missing_year_is_not_reclassified():
 def test_other_real_forecast_errors_are_not_reclassified():
     forecast_module = pytest.importorskip("spm_calculator.rolling_forecast")
     forecast = forecast_module.load_forecast()
-    with pytest.raises(ValueError) as caught:
+    with pytest.raises(
+        ValueError, match="Unknown forecast scenario: unknown-scenario"
+    ) as caught:
         forecast.entry(forecast.years[0], scenario="unknown-scenario")
     assert spm.spm_error_detail(caught.value) is None
 
@@ -321,7 +325,7 @@ def __init__(self, **kwargs):
             pass
 
     class Canonical(Legacy):
-        spm_config = property(lambda self: {})
+        spm_config = property(lambda _self: {})
 
         def spm_provenance(self):
             return {}
@@ -413,7 +417,8 @@ def test_canonical_country_cannot_inherit_the_legacy_exception(monkeypatch, vers
 }
 
 
-def test_resolved_settings_require_explicit_null_values(certified_bundle):
+@pytest.mark.usefixtures("certified_bundle")
+def test_resolved_settings_require_explicit_null_values():
     """A transported resolved config includes all six selection fields."""
     assert spm.resolved_spm_settings(RESOLVED_SELECTION) == RESOLVED_SELECTION
     omitted = {
@@ -442,9 +447,8 @@ def test_resolved_settings_reject_unreadable_receipt_settings(settings):
     assert spm.resolved_spm_settings(settings) is None
 
 
-def test_receipt_reduces_country_diagnostics_to_one_compact_provenance(
-    certified_bundle,
-):
+@pytest.mark.usefixtures("certified_bundle")
+def test_receipt_reduces_country_diagnostics_to_one_compact_provenance():
     """The public receipt itself contains every resolved configuration field."""
     simulation = SimpleNamespace(
         spm_config=RESOLVED_SELECTION,
@@ -539,9 +543,8 @@ def test_a_bundle_this_build_cannot_read_reports_no_validator_internals(
     assert caught.value.message
 
 
-def test_a_country_package_without_a_simulation_is_typed_not_internal(
-    monkeypatch, certified_bundle
-):
+@pytest.mark.usefixtures("certified_bundle")
+def test_a_country_package_without_a_simulation_is_typed_not_internal(monkeypatch):
     """A partially installed model must not make /readiness-check raise.
 
     `is_ready` recovers from RuntimeError and ValueError only, so an escaping
@@ -596,7 +599,7 @@ def record(name):
         raise ImportError(name)
 
     monkeypatch.setattr(spm.importlib, "import_module", record)
-    for country_id, package_name in zip(COUNTRIES, COUNTRY_PACKAGE_NAMES):
+    for country_id, package_name in zip(COUNTRIES, COUNTRY_PACKAGE_NAMES, strict=True):
         assert spm._installed_country_implements_spm(country_id) is False
         assert imported[-1] == package_name
     assert spm._installed_country_implements_spm("nowhere") is False
diff --git a/tests/unit/test_worker_spm_release.py b/tests/unit/test_worker_spm_release.py
index b3a043ecc..3db098e4a 100644
--- a/tests/unit/test_worker_spm_release.py
+++ b/tests/unit/test_worker_spm_release.py
@@ -89,7 +89,7 @@ def test_release_rejects_worker_without_matching_spm_capability(registry, mutati
 @pytest.mark.parametrize("route", ["policyengine", "us", "uk"])
 def test_release_rejects_missing_worker_route(registry, route):
     registry[route] = {}
-    with pytest.raises(ValueError, match="no .* application"):
+    with pytest.raises(ValueError, match=r"no .* application"):
         worker_spm_release.validate_installed_worker(registry, FIXTURE_BUNDLE_VERSION)
 
 
diff --git a/tests/unit/test_yearly_var_removal.py b/tests/unit/test_yearly_var_removal.py
index c2dc439fd..df7cf4c6c 100644
--- a/tests/unit/test_yearly_var_removal.py
+++ b/tests/unit/test_yearly_var_removal.py
@@ -63,7 +63,7 @@ def fake_country_metadata():
 
 def fake_countries():
     return SimpleNamespace(
-        get=lambda country_id: SimpleNamespace(metadata=fake_country_metadata())
+        get=lambda _country_id: SimpleNamespace(metadata=fake_country_metadata())
     )
 
 
diff --git a/tests/unit/v2/test_alembic_v2.py b/tests/unit/v2/test_alembic_v2.py
index b29fd2eaf..4c0e6ee09 100644
--- a/tests/unit/v2/test_alembic_v2.py
+++ b/tests/unit/v2/test_alembic_v2.py
@@ -506,7 +506,7 @@ def test_stage_12a_user_identity_and_association_revision_is_generated() -> None
     assert 'op.create_table(\n        "user_identities"' in revision
     assert '"uq_user_identities_issuer_subject"' in revision
     assert 'op.drop_table("user_identities")' in revision
-    for table_name, reference in (
+    for _table_name, reference in (
         ("user_policies", "policy"),
         ("user_household_associations", "household"),
         ("user_simulation_associations", "simulation"),
@@ -572,10 +572,12 @@ def test_alembic_rejects_unknown_missing_and_divergent_history(tmp_path: Path) -
     (missing / "versions/f5ef4347cb2a_establish_v2_platform_baseline.py").unlink()
     missing_config = Config()
     missing_config.set_main_option("script_location", str(missing))
-    with pytest.warns(UserWarning, match=r"Revision f5ef4347cb2a .* is not present"):
-        missing_script = ScriptDirectory.from_config(missing_config)
-        with pytest.raises((CommandError, KeyError, ResolutionError)):
-            missing_script.get_revision("f5ef4347cb2a")
+    missing_script = ScriptDirectory.from_config(missing_config)
+    with (
+        pytest.warns(UserWarning, match=r"Revision f5ef4347cb2a .* is not present"),
+        pytest.raises((CommandError, KeyError, ResolutionError)),
+    ):
+        missing_script.get_revision("f5ef4347cb2a")
 
     divergent = tmp_path / "divergent"
     shutil.copytree(original, divergent)
diff --git a/tests/unit/v2/test_catalog_publication.py b/tests/unit/v2/test_catalog_publication.py
index 37346a899..a3cbe0d65 100644
--- a/tests/unit/v2/test_catalog_publication.py
+++ b/tests/unit/v2/test_catalog_publication.py
@@ -111,7 +111,7 @@ def execute(self, _statement):
 
 
 class _Inspector:
-    def __init__(self, table_exists: bool):
+    def __init__(self, *, table_exists: bool):
         self.table_exists = table_exists
 
     def has_table(self, table_name: str) -> bool:
@@ -124,13 +124,17 @@ def test_revision_check_rejects_non_postgres_missing_and_wrong_revisions() -> No
         publication._verify_expected_revision(_RevisionConnection(dialect="sqlite"))
 
     with (
-        patch.object(publication.sa, "inspect", return_value=_Inspector(False)),
+        patch.object(
+            publication.sa, "inspect", return_value=_Inspector(table_exists=False)
+        ),
         pytest.raises(publication.CatalogPublicationError, match="table is absent"),
     ):
         publication._verify_expected_revision(_RevisionConnection(dialect="postgresql"))
 
     with (
-        patch.object(publication.sa, "inspect", return_value=_Inspector(True)),
+        patch.object(
+            publication.sa, "inspect", return_value=_Inspector(table_exists=True)
+        ),
         pytest.raises(publication.CatalogPublicationError, match="expected"),
     ):
         publication._verify_expected_revision(
@@ -172,15 +176,6 @@ def test_copy_streams_rows_through_psycopg_without_an_orm_write() -> None:
 def test_publication_uses_mapped_tables_and_sqlalchemy_statements() -> None:
     dialect = postgresql.dialect()
     assert (
-        publication_reconciliation.DATASETS,
-        publication_reconciliation.MODELS,
-        publication_reconciliation.MODEL_VERSIONS,
-        publication_reconciliation.PARAMETERS,
-        publication_reconciliation.PARAMETER_NODES,
-        publication_reconciliation.PARAMETER_VALUES,
-        publication_reconciliation.REGIONS,
-        publication_reconciliation.VARIABLES,
-    ) == (
         Dataset.__table__,
         TaxBenefitModel.__table__,
         TaxBenefitModelVersion.__table__,
@@ -189,6 +184,15 @@ def test_publication_uses_mapped_tables_and_sqlalchemy_statements() -> None:
         ParameterValue.__table__,
         Region.__table__,
         Variable.__table__,
+    ) == (
+        publication_reconciliation.DATASETS,
+        publication_reconciliation.MODELS,
+        publication_reconciliation.MODEL_VERSIONS,
+        publication_reconciliation.PARAMETERS,
+        publication_reconciliation.PARAMETER_NODES,
+        publication_reconciliation.PARAMETER_VALUES,
+        publication_reconciliation.REGIONS,
+        publication_reconciliation.VARIABLES,
     )
     staging_ddl = tuple(
         str(CreateTable(table).compile(dialect=dialect))
diff --git a/tests/unit/v2/test_data_crud_boundaries.py b/tests/unit/v2/test_data_crud_boundaries.py
index 009d66240..96c6d08ea 100644
--- a/tests/unit/v2/test_data_crud_boundaries.py
+++ b/tests/unit/v2/test_data_crud_boundaries.py
@@ -135,7 +135,7 @@ def test_database_session_modules_do_not_construct_queries(
 
 @pytest.mark.parametrize(
     "relative_path",
-    (
+    [
         "identity/services.py",
         "legacy_refs/services.py",
         "user_accounts/services.py",
@@ -143,7 +143,7 @@ def test_database_session_modules_do_not_construct_queries(
         "user_policies/services.py",
         "user_reports/services.py",
         "user_simulations/services.py",
-    ),
+    ],
 )
 def test_user_services_construct_no_sql(relative_path: str) -> None:
     assert not _constructs_sql(SERVICES_ROOT / relative_path)
diff --git a/tests/unit/v2/test_household_routes.py b/tests/unit/v2/test_household_routes.py
index 30be00ec7..3932129b5 100644
--- a/tests/unit/v2/test_household_routes.py
+++ b/tests/unit/v2/test_household_routes.py
@@ -361,9 +361,7 @@ def test_openapi_publishes_query_body_item_page_and_error_schemas() -> None:
     client, _flask_calls = _client(service)
     schema = client.get("/v2/openapi.json").json()
 
-    assert set(
-        path for path in schema["paths"] if path.startswith("/v2/households")
-    ) == {
+    assert {path for path in schema["paths"] if path.startswith("/v2/households")} == {
         "/v2/households",
         "/v2/households/{household_id}",
     }
diff --git a/tests/unit/v2/test_me_routes.py b/tests/unit/v2/test_me_routes.py
index bf7de14d4..1b6533fb8 100644
--- a/tests/unit/v2/test_me_routes.py
+++ b/tests/unit/v2/test_me_routes.py
@@ -53,7 +53,7 @@ def _account(**changes) -> AccountRead:
     return AccountRead(**values)
 
 
-def _result(name: str, kwargs: dict):
+def _result(name: str, _kwargs: dict):
     if name == "export_account":
         return AccountExport(
             user=_account(),
@@ -263,7 +263,7 @@ def test_unauthenticated_principals_reach_every_account_operation() -> None:
 
 
 def test_unauthenticated_account_items_have_no_primary_country() -> None:
-    def result(name: str, kwargs: dict):
+    def result(_name: str, _kwargs: dict):
         return _account(
             id=BROWSER_USER_ID, user_type="unauthenticated", primary_country=None
         )
@@ -284,7 +284,7 @@ def result(name: str, kwargs: dict):
 
 
 def test_absent_unauthenticated_users_read_as_not_found_and_export_empty() -> None:
-    def result(name: str, kwargs: dict):
+    def result(name: str, _kwargs: dict):
         if name == "get_account":
             msg = "The account was not found"
             raise AccountNotFoundError(msg)
@@ -350,7 +350,7 @@ def test_a_credential_naming_a_signed_in_account_asks_the_browser_to_sign_in() -
 def test_upgrade_returns_the_signed_in_account_and_outcome(
     outcome: AccountConversionOutcome, expected: str
 ) -> None:
-    def result(name: str, kwargs: dict):
+    def result(_name: str, _kwargs: dict):
         return AccountUpgrade(account=_account(), outcome=outcome)
 
     client, service = _client(RecordingService(result))
diff --git a/tests/unit/v2/test_models.py b/tests/unit/v2/test_models.py
index 4defaa0bb..20947ffcb 100644
--- a/tests/unit/v2/test_models.py
+++ b/tests/unit/v2/test_models.py
@@ -619,7 +619,7 @@ def test_simulation_and_report_associations_have_no_cross_service_keys() -> None
         assert isinstance(postgres_type, postgresql.JSONB)
     assert set(sa.inspect(UserSimulationAssociation).relationships.keys()) == {"user"}
     assert set(sa.inspect(UserReportAssociation).relationships.keys()) == {"user"}
-    assert "user_associations" not in sa.inspect(Simulation).relationships.keys()
+    assert "user_associations" not in sa.inspect(Simulation).relationships
 
 
 def test_user_policy_records_v3_reform_fields() -> None:
diff --git a/tests/unit/v2/test_policy_legacy_translation.py b/tests/unit/v2/test_policy_legacy_translation.py
index fbdec10e3..d5cf88753 100644
--- a/tests/unit/v2/test_policy_legacy_translation.py
+++ b/tests/unit/v2/test_policy_legacy_translation.py
@@ -294,7 +294,7 @@ def test_reverse_legacy_range_is_rejected() -> None:
 def test_unknown_policyengine_version_never_falls_back() -> None:
     engine, session, _model, _version, _first, _second = _session_and_catalog()
     try:
-        with pytest.raises(Exception, match="running PolicyEngine.py"):
+        with pytest.raises(Exception, match=r"running PolicyEngine\.py"):
             _translate(
                 session,
                 _snapshot(),
diff --git a/tests/unit/v2/test_policy_routes.py b/tests/unit/v2/test_policy_routes.py
index 0eb153d19..1267a14d8 100644
--- a/tests/unit/v2/test_policy_routes.py
+++ b/tests/unit/v2/test_policy_routes.py
@@ -372,7 +372,7 @@ def test_openapi_publishes_request_query_response_and_error_contracts() -> None:
     client, _flask_calls = _client(service)
     schema = client.get("/v2/openapi.json").json()
 
-    assert set(path for path in schema["paths"] if path.startswith("/v2/policies")) == {
+    assert {path for path in schema["paths"] if path.startswith("/v2/policies")} == {
         "/v2/policies",
         "/v2/policies/{policy_id}",
     }
diff --git a/tests/unit/v2/test_settings.py b/tests/unit/v2/test_settings.py
index 38085e680..8a0f03bb8 100644
--- a/tests/unit/v2/test_settings.py
+++ b/tests/unit/v2/test_settings.py
@@ -119,7 +119,7 @@ def test_runtime_rejects_ambiguous_or_invalid_secret_sources(
     with pytest.raises(V2ConfigurationError, match=message):
         load_v2_runtime_database_settings(
             environment,
-            secret_loader=lambda resource: RUNTIME_URL,
+            secret_loader=lambda _resource: RUNTIME_URL,
         )
 
 
@@ -147,7 +147,7 @@ def test_runtime_rejects_an_empty_resolved_secret() -> None:
                 **TARGET_ENVIRONMENT,
                 V2_RUNTIME_DATABASE_URL_SECRET_RESOURCE: RUNTIME_SECRET_RESOURCE,
             },
-            secret_loader=lambda resource: "   ",
+            secret_loader=lambda _resource: "   ",
         )
 
 
diff --git a/tests/unit/v2/test_unauthenticated_user_service.py b/tests/unit/v2/test_unauthenticated_user_service.py
index cdef155ab..59fb13a63 100644
--- a/tests/unit/v2/test_unauthenticated_user_service.py
+++ b/tests/unit/v2/test_unauthenticated_user_service.py
@@ -487,7 +487,8 @@ def test_upgrade_converts_an_unauthenticated_user_in_place(
         identity = session.exec(select(UserIdentity)).one()
         report = session.get(UserReportAssociation, records.report_id)
     assert (identity.user_id, identity.subject) == (BROWSER_USER_ID, ALICE.subject)
-    assert report is not None and report.user_policy_id == records.policy_id
+    assert report is not None
+    assert report.user_policy_id == records.policy_id
     signed_in = services.accounts.get_account(principal=ALICE, country_id="us")
     assert signed_in.id == BROWSER_USER_ID
     with pytest.raises(StandardUserRequiresSignInError):
@@ -528,7 +529,8 @@ def test_upgrade_merges_every_association_into_an_existing_account(
         updated_after = {
             row.id: row.updated_at for row in session.exec(select(UserPolicy)).all()
         }
-    assert report is not None and report.user_policy_id == records.policy_id
+    assert report is not None
+    assert report.user_policy_id == records.policy_id
     assert updated_after == updated_before
     linked = services.reports.get_user_report(
         principal=ALICE, country_id="us", association_id=records.report_id
diff --git a/tests/unit/v2/test_user_household_service.py b/tests/unit/v2/test_user_household_service.py
index 3dec5a04a..944018c53 100644
--- a/tests/unit/v2/test_user_household_service.py
+++ b/tests/unit/v2/test_user_household_service.py
@@ -133,11 +133,13 @@ def test_ownership_repointing_and_deletion(store) -> None:
 
 
 def test_patch_input_rejects_reassignment_and_empty_changes() -> None:
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="At least one of legacy_household_id"):
         UserHouseholdUpdateInput()
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError, match=r"household_id\n  Extra inputs are not permitted"
+    ):
         UserHouseholdUpdateInput.model_validate(
             {"household_id": "00000000-0000-0000-0000-000000000001"}
         )
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="legacy_household_id must not be null"):
         UserHouseholdUpdateInput(legacy_household_id=None)
diff --git a/tests/unit/v2/test_user_policy_legacy.py b/tests/unit/v2/test_user_policy_legacy.py
index 12e594c0d..6ee841ad2 100644
--- a/tests/unit/v2/test_user_policy_legacy.py
+++ b/tests/unit/v2/test_user_policy_legacy.py
@@ -85,9 +85,13 @@ def test_every_mutable_or_v1_only_field_changes_the_fingerprint(
 
 
 def test_snapshot_rejects_unknown_or_unbounded_fields() -> None:
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError, match=r"unexpected\n  Extra inputs are not permitted"
+    ):
         _snapshot(unexpected="value")
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError, match=r"user_id\n  String should have at most 255 characters"
+    ):
         _snapshot(user_id="x" * 256)
 
 
diff --git a/tests/unit/v2/test_user_policy_service.py b/tests/unit/v2/test_user_policy_service.py
index be1a98464..76db00fa3 100644
--- a/tests/unit/v2/test_user_policy_service.py
+++ b/tests/unit/v2/test_user_policy_service.py
@@ -89,7 +89,8 @@ def test_first_save_provisions_the_owner_and_stores_v3_fields(store) -> None:
         user = session.get(User, identity.user_id)
         assert (identity.issuer, identity.subject) == (ALICE.issuer, ALICE.subject)
         assert created.user_id == identity.user_id
-        assert user is not None and user.primary_country == "us"
+        assert user is not None
+        assert user.primary_country == "us"
     assert legacy_references.calls == [("us", {"policy": [1]})]
 
 
@@ -327,11 +328,13 @@ def test_stage_10_projection_records_the_v1_reform_id() -> None:
 
 
 def test_patch_input_requires_a_supported_field() -> None:
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="At least one of legacy_policy_id"):
         UserPolicyUpdateInput()
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError, match=r"policy_id\n  Extra inputs are not permitted"
+    ):
         UserPolicyUpdateInput.model_validate(
             {"policy_id": "00000000-0000-0000-0000-000000000001"}
         )
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="legacy_policy_id must not be null"):
         UserPolicyUpdateInput(legacy_policy_id=None)
diff --git a/tests/unit/v2/test_user_route_auth.py b/tests/unit/v2/test_user_route_auth.py
index 108545fa3..37c4c4c35 100644
--- a/tests/unit/v2/test_user_route_auth.py
+++ b/tests/unit/v2/test_user_route_auth.py
@@ -46,7 +46,7 @@ def configured_auth(monkeypatch: pytest.MonkeyPatch):
 
     def install(claims: Mapping[str, Any] | Exception) -> FakeDecoder:
         decoder = FakeDecoder(claims)
-        monkeypatch.setattr(user_auth, "_decoder", lambda issuer, audience: decoder)
+        monkeypatch.setattr(user_auth, "_decoder", lambda _issuer, _audience: decoder)
         return decoder
 
     return install
@@ -312,9 +312,10 @@ def _without_auth_settings(monkeypatch: pytest.MonkeyPatch) -> None:
         monkeypatch.delenv(name, raising=False)
 
 
+@pytest.mark.usefixtures("configured_auth")
 @pytest.mark.parametrize("auth_configured", [False, True])
 def test_the_unauthenticated_user_header_authenticates_a_signed_out_browser(
-    monkeypatch: pytest.MonkeyPatch, configured_auth, auth_configured: bool
+    monkeypatch: pytest.MonkeyPatch, *, auth_configured: bool
 ) -> None:
     if not auth_configured:
         _without_auth_settings(monkeypatch)
diff --git a/tests/unit/v2/test_user_simulation_report_routes.py b/tests/unit/v2/test_user_simulation_report_routes.py
index f5d65a6d9..9a5aca120 100644
--- a/tests/unit/v2/test_user_simulation_report_routes.py
+++ b/tests/unit/v2/test_user_simulation_report_routes.py
@@ -215,7 +215,7 @@ def test_report_routes_round_trip_v3_fields() -> None:
             "user_policy_id": str(USER_POLICY_ID),
             "baseline_user_policy_id": str(BASELINE_USER_POLICY_ID),
             "source_note": "from chat",
-            "provisions": PROVISIONS + [GROWING_PROVISION],
+            "provisions": [*PROVISIONS, GROWING_PROVISION],
             "validation": VALIDATION,
             "budget_window_years": 10,
             "last_run_at": "2026-02-01T12:00:00Z",