📝 docs(adr): update ADR-121 with actual performance findings

Update ADR-121 to reflect measured CI performance:
- ~20% improvement (13 min → 10 min), not the initially estimated 75%+
- Document that xdist parallelization limits fixture sharing benefits
- Add "Disable xdist" as rejected alternative (26 min sequential)
- Clarify the observed limitation with 4 xdist workers

Issue: #253

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: sodre

docs/adr/121-module-scoped-test-fixtures.md

@@ -6,9 +6,9 @@
 
 ## Context
 
-Integration tests against LocalStack create and destroy DynamoDB tables for each test function. With 19 tests, this results in 19 table creation/deletion cycles, each taking several seconds. The cumulative overhead causes the integration test suite to run for approximately 15 minutes, creating friction in the development workflow and slowing CI feedback loops.
+Integration tests against LocalStack create and destroy DynamoDB tables for each test function. With 19 tests distributed across 4 pytest-xdist workers, this results in multiple table creation/deletion cycles per worker. The cumulative overhead causes the integration test suite to run for approximately 13 minutes.
 
-The tests are isolated at the data level—each test creates distinct entities and buckets—but share no infrastructure. This isolation pattern is overly conservative since tests do not interfere with each other's data when using unique entity identifiers.
+The tests are isolated at the data level—each test creates distinct entities and buckets—but share no infrastructure within each worker. This isolation pattern is overly conservative since tests do not interfere with each other's data when using unique entity identifiers.
 
 ## Decision
 
@@ -17,22 +17,31 @@ Integration tests must use module-scoped pytest fixtures (`localstack_repo_modul
 ## Consequences
 
 **Positive:**
-- Integration test runtime reduced from ~15 minutes to ~68 seconds (parallel) or ~2 minutes (sequential)
+- Integration test runtime reduced by ~20% (from ~13 minutes to ~10 minutes with xdist)
 - Same isolation guarantees maintained through unique entity prefixes
 - Pattern aligns with E2E tests which already use class-scoped fixtures
+- Cleaner fixture naming convention with scope in name
 
 **Negative:**
 - Tests must use `loop_scope="module"` on both fixtures and test markers for async compatibility
 - Debugging failures requires understanding that data from other tests exists in the shared table
 - Tests that require clean infrastructure state must use function-scoped fixtures explicitly
 
+**Observed Limitation:**
+The improvement is modest (~20%) because CI runs with pytest-xdist (`-n auto --dist loadscope`), which distributes test modules across 4 workers. Each worker creates its own module-scoped fixtures, so the total stack count equals the worker count rather than 1.
+
+Disabling xdist to maximize fixture sharing was tested and rejected—sequential execution took ~26 minutes vs ~10 minutes with xdist. Parallelization benefits outweigh stack creation overhead.
+
 ## Alternatives Considered
 
+### Disable xdist for integration tests
+Rejected because: Sequential execution (~26 min) is significantly slower than parallel execution with per-worker stacks (~10 min). The parallelization benefit exceeds the stack creation overhead.
+
 ### Class-scoped fixtures
-Rejected because: Module scope maximizes sharing across test classes, reducing infrastructure creation from once-per-class to once-per-module.
+Rejected because: Module scope maximizes sharing across test classes within each xdist worker, reducing infrastructure creation from once-per-class to once-per-module.
 
 ### Session-scoped fixtures
 Rejected because: Session scope would share infrastructure across test modules, making test isolation harder to reason about and potentially causing cross-module interference in CI parallel execution.
 
 ### Per-test table creation (status quo)
-Rejected because: The ~15 minute runtime creates unacceptable friction for development iteration.
+Rejected because: The ~13 minute runtime creates friction for development iteration. Even a 20% improvement is worthwhile.