Let a carrier be told what to carry

The peer had no way to be given a subject. It carried its own, whatever it had
been paired with, and whatever a bucket-topic announcement told it about — and
that announcement has to arrive over an overlay whose membership is sampled, so
sometimes it simply does not. Twenty minutes of `carrying 1 · holding 0 ·
heard 0` while the data sat in its own store.

`--carry <subject-hex>`, repeatable. `carry_share` already carried follows
unconditionally every pass; this puts named subjects on the same footing.
Somebody running a carrier for their own family already knows whose records they
mean, and should not have to wait to be told.

Measured: first pass after the restart, `carrying 4 (+4) · holding 1798`.
Discovery is out of the path for the subjects the machine exists to hold.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: alex-poor

crates/diaswarm-android/src/lib.rs

@@ -2485,6 +2485,8 @@ pub extern "system" fn Java_nz_diaswarm_jni_SwarmNative_keysCarryAll<'a>(
         &store,
         &own,
         max_adopt.max(0) as usize,
+        // A phone is told whom to carry by pairing, not by a flag.
+        &[],
     )) {
         Ok(share) => share.carrying as jlong,
         Err(_) => -4,

crates/diaswarm-net/src/share.rs

@@ -19,7 +19,7 @@ use std::path::Path;
 use anyhow::Result;
 
 use crate::replicate::KeysReplicator;
-use crate::swarm::Swarm;
+use crate::swarm::{is_subject, Swarm};
 
 /// What one pass over the pool did.
 ///
@@ -78,6 +78,7 @@ pub async fn carry_share(
     store: &Path,
     own_subject: &str,
     max_adopt: usize,
+    also: &[String],
 ) -> Result<Share> {
     // `.max(2)` because a pool of one has no depth to speak of and the first
     // pass usually runs before anybody has been heard from.
@@ -86,6 +87,14 @@ pub async fn carry_share(
 
     let mut wanted: Vec<String> = vec![own_subject.to_string()];
 
+    // **SUBJECTS THIS PEER WAS TOLD TO CARRY, WHICH NEED NO GOSSIP AT ALL.**
+    // Everything else here waits to be told: follows come from a pairing, and
+    // strangers from a `HoldingKeys` announcement that has to arrive over an
+    // overlay whose membership is sampled. A carrier somebody runs for their
+    // own family should not be at the mercy of that — they already know whose
+    // data they mean. Named subjects are carried every pass, unconditionally.
+    wanted.extend(also.iter().filter(|s| is_subject(s)).cloned());
+
     // Everyone we follow, by the keys identity their invite carried. A follow
     // with no keys identity is skipped rather than failed: it is somebody
     // paired before the field existed, or a subject with no keys vault.

crates/diaswarm-net/src/swarm.rs

@@ -904,7 +904,7 @@ fn topic(bytes: [u8; 32]) -> Topic {
     Hash::from_bytes(bytes).into()
 }
 
-fn is_subject(s: &str) -> bool {
+pub(crate) fn is_subject(s: &str) -> bool {
     s.len() == 64 && s.bytes().all(|b| b.is_ascii_hexdigit())
 }
 

crates/diaswarm-net/tests/keys_pool.rs

@@ -129,6 +129,7 @@ async fn a_stranger_carries_a_keys_subject_it_was_never_introduced_to() {
             &carrier_dir,
             &carrier_own,
             4,
+            &[],
         )
         .await
         {

crates/diaswarm-peer/src/main.rs

@@ -72,6 +72,19 @@ struct Args {
     #[arg(long, value_name = "NAME")]
     network: Option<String>,
 
+    /// Carry this subject, whatever gossip does or does not say. Repeatable.
+    ///
+    /// **THE ONE WAY TO BE SURE.** Everything else this peer carries it has to
+    /// be *told about*: a follow comes from a pairing, a stranger from an
+    /// announcement that has to reach it over an overlay whose membership is
+    /// sampled and can simply not include the peer holding the data. A carrier
+    /// somebody runs for their own family already knows whose records it means;
+    /// naming them here removes discovery from the path entirely.
+    ///
+    /// Take the value from the phone's log line `swarm: keys subject <hex>`.
+    #[arg(long = "carry", value_name = "SUBJECT-HEX")]
+    carry: Vec<String>,
+
     /// Do one pass and exit.
     #[arg(long)]
     once: bool,
@@ -231,7 +244,8 @@ async fn main() -> Result<()> {
     loop {
         let tick = swarm.tick().await;
         let share =
-            diaswarm_net::share::carry_share(&swarm, &replicator, &dir, &own, args.adopt).await;
+            diaswarm_net::share::carry_share(&swarm, &replicator, &dir, &own, args.adopt, &args.carry)
+                .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.**