@@ -172,7 +172,41 @@ impl Swarm {
         let store = store.into();
         std::fs::create_dir_all(&store)?;
 
-        let book = AddressBook::builder().spawn().await.context("address book")?;
+        // **GIVE THE ADDRESS BOOK A STORE, WHICH IS WHAT IT IS FOR.**
+        // `AddressBook::builder()` with no store keeps everything in memory, so
+        // `node_infos_v1` and `topics2node_infos_v1` stay empty for ever and a
+        // peer restarts knowing nobody. Measured on a laptop: `pool 4` reported
+        // while the persisted node table held **zero** rows.
+        //
+        // p2panda's own description of what is being thrown away: the address
+        // book "is an important tool to watch for transport information
+        // changes, keep track of stale nodes and identify network partitions
+        // which can be automatically healed". A peer that syncs with one node
+        // and never another is that last sentence exactly.
+        //
+        // **ITS OWN FILE, NOT THE KEYS STORE.** `p2panda-store` builds its pool
+        // with `max_connections(1)` and no busy timeout, so two pools on one
+        // SQLite file is a writer-contention bug rather than an untidiness —
+        // the note on `Pooled` in `diaswarm-android` says so at length. A
+        // separate file costs nothing and shares nothing.
+        //
+        // Done here rather than as a parameter because `Swarm` already owns a
+        // directory and there are 47 call sites that should not have to care.
+        let book_url = format!("sqlite://{}", store.join("addressbook.sqlite").display());
+        let book = match p2panda_store::SqliteStoreBuilder::new()
+            .database_url(&book_url)
+            .create_database(true)
+            .build()
+            .await
+        {
+            Ok(db) => AddressBook::builder().store(db).spawn().await.context("address book")?,
+            Err(e) => {
+                // A peer with an unpersisted address book still works; it just
+                // forgets everyone on restart. Worth saying, not worth refusing.
+                eprintln!("diaswarm: address book not persisted ({e}) — peers are forgotten on restart");
+                AddressBook::builder().spawn().await.context("address book")?
+            }
+        };
 
         // SEED WHOEVER WE ALREADY KNOW, BEFORE THE ENDPOINT STARTS. A follower
         // scanned exactly one thing: the subject's node id. That is enough to
 
@@ -234,6 +234,11 @@ async fn main() -> Result<()> {
             diaswarm_net::share::carry_share(&swarm, &replicator, &dir, &own, args.adopt).await;
         let bytes = disk_bytes(&dir);
         let stored = held(&store, &replicator.carried()).await;
+        // **HOW MANY SUBJECTS IT HAS HEARD OF BUT IS NOT YET CARRYING.**
+        // Without this, "carrying 1" is ambiguous between "nobody has told me
+        // about anybody" and "I was told and did not act", which are different
+        // bugs in different files. Costs one in-memory read.
+        let heard_waiting = swarm.keys_wanted().await.map(|w| w.len()).unwrap_or(0);
         if stored > was_held {
             stalled_for = 0;
         } else if stored > 0 {
@@ -251,8 +256,9 @@ async fn main() -> Result<()> {
                     );
                 } else {
                     println!(
-                        "pool {} · carrying {} (+{}) · holding {} · pushes {} · {}{}",
+                        "pool {} · heard {} · carrying {} (+{}) · holding {} · pushes {} · {}{}",
                         t.pool,
+                        heard_waiting,
                         s.carrying,
                         s.adopted,
                         stored,
@@ -265,6 +271,23 @@ async fn main() -> Result<()> {
                         },
                     );
                 }
+                // **RE-SUBSCRIBE WHEN IT HAS CLEARLY STOPPED**, which is the
+                // remedy Ayni has had since the phones hit this exact symptom:
+                // catch-up delivers once on connect and live mode then produces
+                // nothing for ever, `received_live_operations: 0` on every
+                // session while `LiveModeStarted` keeps firing. Dropping the
+                // handles and streaming the topics again is what brings it
+                // back there, and the peer simply never had it.
+                //
+                // Three passes, not one: a pass with nothing new is ordinary
+                // when the publisher has nothing to say, and re-subscribing on
+                // every quiet minute would be its own kind of broken.
+                if stalled_for >= 3 && stalled_for % 3 == 0 {
+                    match replicator.restream().await {
+                        Ok(n) => println!("    stalled — re-subscribed {n} topic(s)"),
+                        Err(e) => println!("    stalled — re-subscribe failed: {e:#}"),
+                    }
+                }
                 // The events, when asked for, or unprompted once a stall is
                 // undeniable — because that is the moment somebody needs them.
                 if args.events > 0 || stalled_for == 3 {