# Transaction Guide Design §15-§20. What owns a transaction, what may be retried, and what must never be. ## The application service owns the boundary Repository adapters do not open transactions. The use case does, through `TransactionPort`, because the unit of work is a business decision and only the use case knows where it starts and ends. `SpringTransactionPort` is the only implementation: one pre-built `TransactionTemplate` per mode over Spring's `PlatformTransactionManager`, every mode pinned to `READ_COMMITTED`. | Call | Propagation | When | |---|---|---| | `inWrite` | `REQUIRED`, read-write | command default | | `inRootWrite` | `REQUIRED`, read-write, rejects an ambient transaction before running | orchestration that must prove a physical commit | | `inRead` | `REQUIRED`, read-only | query default | | `inNew` | `REQUIRES_NEW`, read-write | outbox / audit / compensation that must commit on its own | Open Session In View is off in every runtime profile. It is on by default in Spring Boot, which is why `JpaDangerousConfigurationGuard` fails startup rather than trusting configuration review. `REQUIRES_NEW` acquires a second physical connection while pinning the first, so the pool must satisfy: ```text maximumPoolSize >= (concurrent_threads x (1 + max_requires_new_depth)) + 1 ``` ## Nothing is retried by the port `SpringTransactionPort` runs the action once. A failure rolls back and propagates, translated to the shared persistence error codes where the SQLSTATE is known. A caller that decides to retry must re-run the whole use case in a new transaction — never re-issue one statement — because an optimistic conflict or a serialization failure means the state the attempt computed against is no longer the committed state. A second engine with named policies, deadline budgets, transaction-local timeouts and automatic full-transaction retry (`SpringJpaTransactionExecutor`, `FullTransactionRetryCoordinator`, `PolicyTransactionPort`) existed next to this one and was removed on 2026-09-25. Its last commit is recorded in `docs/capability-status.md`. ## Completion unknown A connection can break while a commit is in flight; the server may have committed and only the acknowledgement was lost. `TransactionCompletionUnknownException` is never retried, and the type system enforces it: `JpaFailureContext` refuses to represent a retryable completion-unknown failure. The port itself retries nothing, so such a commit surfaces to the caller as a failure exactly once (`PostgreSqlTransactionIntegrationTest#connectionLossDuringCommitSurfacesAsAFailureAndIsNeverRetried`). Recovery is reconciliation, not retry: ```text check the idempotency record -> check the business row -> check the outbox -> still undetermined? escalate ```