Keep the store's one connection, delete the seam it cannot survive (V-642)

`SetMaxOpenConns(1)` under WAL gives up concurrent reads, and the task
asked whether that costs anything. Measured over a fixed two-second
window, a paced writer against a read loop, three runs per cap:
reads do not queue. Four connections buy 70µs at p50 on a turn that
spends 1.19s in the resident model, and write throughput more than
halves. A 19ms worst case also cannot be the source of the 2.7s router
figure, so that line of enquiry is closed.

What the cap cannot survive is a long-lived transaction. It holds the
only connection, so a second read never completes: two seconds and
`context deadline exceeded`, against 1ms at a cap of four.

`Store.DB` handed out exactly that transaction. It had been there since
the initial commit with no production caller, and its comment described
a loop that never materialised. Its one user was a test helper reading
`delivery_attempts` by raw SQL, which `ListDeliveryAttempts` has covered
since V-390. So the cap stays and the seam goes, and the hazard is gone
by construction rather than by documentation.

`internal/store/conncap_test.go` stays as the standing measurement,
skipped under -short. The comment at the cap and the one in
`internal/ipc/server.go` that leans on it now state the invariant and
cite the numbers.

Measurement: docs/evals/2026-08-07-store-connection-cap.md

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

internal/store/store.go

@@ -95,7 +95,20 @@ func openAt(ctx context.Context, path string) (*sql.DB, error) {
 	if err != nil {
 		return nil, fmt.Errorf("open %s: %w", path, err)
 	}
-	// single writer expected; the daemon is the only process touching the db.
+	// One connection, so every statement is serialised at the database and no
+	// caller above needs a lock of its own. internal/ipc's Server relies on
+	// exactly this, which is why the cap is an invariant rather than a tuning
+	// knob: raising it moves the serialisation guarantee somewhere it is not
+	// written down.
+	//
+	// Measured on 07-08-2026 (V-642, docs/evals/2026-08-07-store-connection-cap.md).
+	// WAL exists to let readers run beside one writer, and the cap gives that
+	// up, but reads do not queue: p50 594µs against 525µs at a cap of four,
+	// while write throughput more than halves. The one thing the cap cannot
+	// survive is a long-lived transaction, which holds the only connection and
+	// stalls every read for its lifetime. So the store begins none, and
+	// TestConnCap_ReadBlocksBehindOpenSnapshot is the standing measurement of
+	// what re-adding one would cost.
 	db.SetMaxOpenConns(1)
 	if _, err := db.ExecContext(ctx, schemaSQL); err != nil {
 		if closeErr := db.Close(); closeErr != nil {
@@ -133,13 +146,6 @@ func (s *Store) Close() error {
 	return s.enc.closeAndSeal(s.db)
 }
 
-// DB exposes the underlying handle for internal read-only snapshots.
-// Used by the loop to take a consistent read under a single transaction.
-// Modules never receive this handle — core mediates.
-func (s *Store) DB(ctx context.Context) (*sql.Tx, error) {
-	return s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
-}
-
 var (
 	// ErrNoFact — no non-voided row exists for this key.
 	ErrNoFact = errors.New("store: no fact for key")